多线程
线程是程序执行的一台路径，一个进程中可以包含多条线程
多线程并发执行可以提高程序的效率，可以同时完成多项工作
多线程的应用背景
红蜘蛛同时共享屏幕给多个电脑
迅雷开启多条线程一起下载
QQ同时和多个人一起视频
服务器同时处理多个客户端请求
多线程并行和并发
并行就是两个任务同时运行，就是甲任务进行的同时，乙任务也在进行（需要多核CPU）
并发是指两个任务都请求运行，而处理器只能接受一个任务，就把这两个任务轮流进行，由于时间间隔较短，使人感觉两个任务都在运行
比如我跟两个网友聊天，左手操作一个电脑跟甲聊，同时右手用另一台电脑跟乙聊天，这就叫并行
如果用一台电脑我先给甲发个信息，然后立刻再给乙发信息，然后再跟甲聊，再跟乙聊。这就叫并发
java程序运行原理和jvm的启动
*java命令启动java虚拟机，启动jvm，等于启动了一个应用程序，也就是启动了一个进程，该进程会自动启动一个 “ 主线程 ”，然后主线程去调用某个类的 main 方法
*jvm启动至少启动了垃圾回收线程和主线程，所以是多线程的
多线程程序实现
1. 继承Thread
定义类继承Thread
重写run方法
把新线程要做的是写在run方法中
创建线程对象
开启新线程，内部会自动执行run方法
public class demo1_thread { public static void main(String[] args) { mythread mt1 =new mythread(); //创建thread类的子类对象 mt1.start(); //开启线程 for(int i=0;i<1000;i++){ System.out.println("bbbbb"); } } } class mythread extends Thread{ //继承thread public void run(){ //重写run方法 for(int i=0;i<1000;i++){ System.out.println("aaaaaaaaaa"); } } }
2. 实现runnable
定义类显示Runnable接口
实现run方法
把新线程要做的事写在run方法中
创建自定义的Runnable的子类对象
创建Thread对象，传入Runnable
调用start（）开启新线程，内部会自动调用Runnable的run方法
public class demo2_Runnnbale { public static void main (String args []){ myrunnbale mr =new myrunnbale(); //创建runnable的子类对象 new Thread(mr).start(); //将其当做参数传递给thread的构造函数,并开启线程 for (int i = 0; i < 1000; i++) { System.out.println("cc"); } } } class myrunnbale implements Runnable{ @Override public void run() { for (int i = 0; i < 1000; i++) { System.out.println("aaaaaaaaaaaaaa"); } } }
实现Runnable的原理
看Thread类的构造函数，传递了Runnable接口的引用
通过init（）方法找到传递的target给成员变量的target赋值
查看run方法，发现run方法中有判断，如果target不为null就会太哦用Runnable接口子类对象的run方法
两种方式的区别
1.继承Thread：由于子类重写了Thread类的run（），方太哦用start（）时，直接找子类的run（）方法
2.实现Runnable：构造函数中传入了Runnable的引用，成员变量记住了它，start（）调用run（）方法时内部成员变量Runnable引用是否为空，不为空编译时看的siRunnable的run（），运行时执行的狮子类的run（）方法
继承Thread：
好处是：可以直接使用Thread类中的方法，代码简单
弊端是：如果已经有父类，就不能用这种方法
实现Runnable接口：
好处是：即使自己定义的县城类有了父类也没关系，因为有了父类也可以实现接口，而且接口是可以多实现的
弊端是：不能直接使用Thread中的方法需要先获取到线程对象后，才能得到Thread的方法，代码复杂
匿名内部类实现线程
1.继承Thread方法
2.实现Runnable方法
public class demo3_Thread { public static void main(String[] args) { new Thread(){ //继承Thread方法 public void run(){ //重写run方法 for (int i = 0; i < 3000; i++) { System.out.println("aaaaaaaaa"); } } }.start(); //开启线程 new Thread(new Runnable(){ public void run(){ for (int i = 0; i < 3000; i++) { System.out.println("bbb"); } } }).start(); } }
获取名字
1.通过geyName（）方法获取线程对象的名字
设置名字
2.通过构造方法函数可以传入String类型的名字
通过setName（String）方法可以设置线程对象的名字
public class demo1_Name { public static void main (String args[]){ new Thread("大哥"){ public void run(){ System.out.println(this.getName()+"aaaaaaaa"); } }.start(); new Thread(){ public void run(){ this.setName("战三"); System.out.println(this.getName()+"bb"); } }.start(); Thread t1= new Thread("大哥"){ public void run(){ System.out.println(this.getName()+"aaaaaaaa"); } }; t1.setName("李"); t1.start(); } }
获取当前线程的对象
Thread.currentThread（），主线程也可以获取
public class demo2_currentthread { public static void main(String[] args) { new Thread("毛毛"){ public void run (){ System.out.println(getName()+"...aaaaaaa"); } }.start(); new Thread(new Runnable(){ public void run(){ //Thread.currentThread()获取当前正在执行的线程 System.out.println(Thread.currentThread().getName()+"...bb"); } }).start(); Thread.currentThread().setName("主线程"); System.out.println(Thread.currentThread().getName()); } }
休眠线程
Thread.sleep（毫秒，纳秒），控制当前线程休眠若干毫秒1秒 =1000 * 1000 * 1000纳秒 1000000000
public class demo3_seelp { public static void main(String[] args) throws InterruptedException { //demo1(); new Thread(){ public void run(){ for (int i = 20; i >=0; i--) { try { Thread.sleep(1000); } catch (InterruptedException e) { // TODO Auto-generated catch block e.printStackTrace(); } System.out.println(getName()+"...a"); } } }.start(); new Thread(){ public void run(){ for (int i = 20; i >=0; i--) { try { Thread.sleep(1000); } catch (InterruptedException e) { // TODO Auto-generated catch block e.printStackTrace(); } System.out.println(getName()+"..bb"); } } }.start(); } public static void demo1() throws InterruptedException { for(int i=20;i>=0;i--){ Thread.sleep(1000); System.out.println("倒计时"+i+"秒"); } } }
守护线程
setDaemon（），设置一个线程为守护线程，该线程不会单独执行，当其他飞守护线程都执行结束后，自动退出
public class demo4_daemon { public static void main(String[] args) { Thread t1 =new Thread(){ public void run(){ for (int i = 0; i < 2; i++) { System.out.println(getName()+"..aaaaaaaa"); } } }; Thread t2 =new Thread(){ public void run(){ for (int i = 0; i < 50; i++) { System.out.println(getName()+"..bb"); } } }; t2.setDaemon(true); //当传入true就是意味着设置为守护线程 t1.start(); t2.start(); } }
加入线程
join（），当前线程暂停，等待指定的线程执行结束后，当前线程在继续
join（int），可以等待指定的毫秒之后继续
public class demo5_Join { public static void main(String[] args) { final Thread t1 =new Thread(){ public void run (){ for(int i=0; i<10 ;i++){ System.out.println(getName()+"...aaaaaaaaa"); } } }; Thread t2 =new Thread(){ public void run (){ for(int i=0; i<10 ;i++){ if(i==2){ try { t1.join(1); } catch (InterruptedException e) { e.printStackTrace(); } } System.out.println(getName()+"...bb"); } } }; t1.start(); t2.start(); } }
礼让线程
yield让出cpu
设置线程的优先级
setPriority（） 设置线程的优先级
N1.setPriority(Thread.MIN_PRIORITY); //设置最大的线程优先级
N2.setPriority(Thread.MAX_PRIORITY); //设置最小线程优先级
同步代码块
什么情况下需要同步
当多线程并发，有多段代码同时执行是，我们希望某一段代码执行的过程中cpu不要切换到其他线程工作，这是就需要同步
如果两端代码是同步的，那么同一时间值执行一段，在一段代码每执行结束之前，不会执行另一端代码
同步代码块
使用synchronized关键字加上一个锁对象来定义一段代码，这就叫同步代码块
多个同步代码块如果使用相同的锁对象，那么他们就是同步的
public class test_sybchronized { public static void main(String[] args) { final pritner p1=new pritner(); new Thread(){ public void run(){ while(true){ p1.print1(); } } }.start(); new Thread(){ public void run(){ while(true){ p1.print2(); } } }.start(); } } class pritner{ demo d=new demo(); public void print1(){ synchronized (d) { System.out.println("学习"); } } public void print2(){ System.out.println("学校"); } } class demo{}
同步方法
*使用synchronized 关键字修饰一个方法，该方法中所有的代码都是同步的
public class test2_sybchronized { public static void main(String[] args) { final pritner2 p1=new pritner2(); new Thread(){ public void run(){ while(true){ p1.print1(); } } }.start(); new Thread(){ public void run(){ while(true){ p1.print2(); } } }.start(); } } class pritner2{ //非静态放入同步方法的锁对象是this //静态的锁不方法的锁对象是：该类的字节码对象 public synchronized void print1(){ System.out.print("学"); System.out.print("习"); System.out.print("的"); System.out.print("心"); System.out.print(" "); } public void print2(){ synchronized (this) { System.out.print("学"); System.out.print("校"); System.out.print("的"); System.out.print("路"); System.out.print("上"); System.out.print(" "); } } }
线程安全问题
多线程并发操作同一数据时，就有可能出现线程安全问题
使用同步技术可以解决这种问题，把操作数据的代码进行同步，不要多个线程一起操作
public class test2_ticket { public static void main(String[] args) { new ticket().start(); new ticket().start(); new ticket().start(); new ticket().start(); } } class ticket extends Thread{ private static int ticket =100; public void run(){ while(true){ synchronized (ticket.class) { if(ticket <=0){ break; } try { Thread.sleep(10); } catch (InterruptedException e) { // TODO Auto-generated catch block e.printStackTrace(); } System.out.println(getName() + "...这是第" + ticket-- + "号票"); } } } }
死锁
多线程同步的时候，如果同步代码嵌套，使用相同锁，就有可能出现死锁
public class test3_ { private static String s1 ="筷子左"; private static String s2 ="筷子右"; public static void main(String[] args) { new Thread(){ public void run (){ while(true){ synchronized (s1) { System.out.println(getName()+"读取"+s1+"等待"+s2); synchronized (s2) { System.out.println(getName()+"拿到"+s2+"吃"); } } } } }.start(); new Thread(){ public void run (){ while(true){ synchronized (s2) { System.out.println(getName()+"读取"+s2+"等待"+s1); synchronized (s1) { System.out.println(getName()+"拿到"+s1+"吃"); } } } } }.start(); } }