devbox
凡人多烦事01
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

什么是多线程? 了解多线程的实现方式 线程方法 及线程安全问题_方法内多线程

作者：凡人多烦事01 | 2024-05-12 21:11:31

赞

踩

方法内多线程

什么多线程?
    是指从软件或者硬件上实现多个线程并发执行的技术
    具有多线程能力的计算机因为有硬件的支持而能够在同一时间执行多个线程,提高性能

并发和并行:

并行: 同一个时刻,多个指令在多个cpu上同时执行 

并发:  同一个时刻,多个指令在一个cpu上交替执行

进程和线程 :

什么是进程   
    进程:正在运行的软件
     >独立性:进程是一个能独立运行的基本单位,同时也是系统分配资源和调度的独立单位
     >动态性:进程的实质是程序的一次执行过程,进程是动态产生,动态消亡的
     >并发性:任何进程都可以同其他进程一起并发执行

什么是线程  
    线程:是进程中的单个顺序控制流程,是一条直行路径 
      >单线程:一个进程如果只有一条执行路径,则称为单线程程序 (之前写的程序)
      >多线程:一个线程如果有多条执行路径,则称为多线程程序

多线程的实现方式-

1.继承Thread 

java的jvm允运行多个线程,它通过java.lang.Thread类来体现
    Thread类的特性:
        >每个线程都是通过某个特定的Thread对象的run()方法来完成操作,经常把run()方 法的主体称为线程体
        >通过Thread对象的start()方法来启动这个线程,而非是直接调用run()方法

  1. class MyThread extends Thread {
  2. 	
  3.     @Override
  4.     public void run() {
  5.         for (int i = 0; i < 100; i++) {
  6.             System.out.println(i);
  7.         }
  8.     }
  9. }
  1. public class Demo1 {
  2.     public static void main(String[] args) {
  3.     	/*	现在只有1个线程,任何java程序起码有个主线程 main  
  4. 			MyThread t1=new MyThread();并不是一个线程
  5. 			只是创建了一个线程对象(线程对象和线程还是有很大区别的 
  6. 			对象是创建在虚拟机堆空间中的,
  7. 			而线程是操作系统维护的一种资源 为什么说Thread对象代表一个线程?
  8. 			因为把线程对象创建出来以后,以他为代表才能创建线程,
  9. 			我们程序员不能绕开虚拟机工作,不能直接去访问操作系统),
  10. 		*/	
  11.      	MyThread t1=new MyThread();
  12. 		MyThread t2=new MyThread();
  13.         //通过此对象调用start方法 : ①启动当前线程,② 调用当前线程的run()方法
  14.         //start() 线程对象会帮你到操作系统中发出申请能不能为我创建一个线程 
  15.         //如果得到批准操作系统就创建一个新线程
  16. 		//这才是创建线程 或者是启动线程
  17.         t1.start();
  18.                //这句话是在主线程中执行的
  19.       System.out.println("你好世界");
  20.         t2.start();
  21.       
  22.     }
  23. }    
  24. //cup的切换是随机的 所以看到的结果每次是不一样的

 

可以看到,第一条线程到25后,第二条线程执行.交替执行

cpu的切换是随机的 所以每次运行看到的结果每次是不一样的

  为什么要重写run()方法
    因为run()方法是用来封装被线程执行的代码
    
 run()和start()方法的区别?   
    如果直接调用run()方法,表示的仅仅是创建对象,用对象去调用方法,并没有开启线程
    相当于是普通方法的调用
    native 表示的调用的本地方法 是和操作系统进行交互的方法
        
    start():表示启动线程,然后由jvm调用此线程的run()方法

代码演示

 

  1. class MyThread extends Thread {
  2.     @Override
  3.     public void run() {
  4.         for (int i = 0; i < 100; i++) {
  5.             System.out.println(Thread.currentThread().getName()+"-"+i);
  6.         }
  7.     }
  8. }
  9. //注意点1 不能直接调用run方法的方式启动线程
  10. public class Demo1 {
  11.     public static void main(String[] args) {
  12.         new MyThread().run();
  13.         //在主线程中调用run方法 还是单线程执行,没有开辟新的线程
  14.         //这个打印的线程名 是主线程的
  15.     }
  16. }
  17. //注意点2 不能同一个线程启动两次  如果想启动两个线程就只能创建一个新的线程对象
  18. public class Demo1 {
  19.     public static void main(String[] args) {
  20.         MyThread m1 = new MyThread();
  21.         m1.start();
  22.         m1.start();//不能同一个线程启动两次
  23.         //java.lang.IllegalThreadStateException
  24.     }
  25. }

多线程的实现方式-

2.实现Runnable接口 

代码演示:

1 创建一个实现了Runnable接口的类
2 重写run()方法
3 创建此类的对象
4 创建Thread类的对象并以此类的对象作为构造参数
5 通过Thread类的对象调用start()方法 

  1. class MyThread implements Runnable{
  2.     @Override
  3.     public void run() {
  4.         for (int i = 0; i < 100; i++) {
  5.            System.out.println(Thread.currentThread().getName()+"-"+i);
  6.         }
  7.     }
  8. }
  1. public class Demo1 {
  2.     public static void main(String[] args) {
  3.         MyThread myThread = new MyThread();
  4.         Thread thread1 = new Thread(myThread,"线程一");
  5.         thread1.start();
  6.         for (int i = 0; i < 100; i++) {
  7.             System.out.println(Thread.currentThread().getName()+"-"+i);
  8.         }
  9.  
  10.         //如何再启动一个线程
  11.         Thread thread2 = new Thread(myThread);
  12.         thread2.setName("线程二");
  13.         thread2.start();
  14.  
  15.     }
  16. }

运行结果: 

cpu的切换是随机的 所以每次运行看到的结果每次是不一样的 

多线程的实现方式-

3.实现callable接口

jdk5.0
实现Callable接口
与Runnable接口相比，callable功能更强大
    1 相比run方法可以有返回值
    2 方法可以抛出异常
    3 支持泛型的返回值
    4 需要借助FutureTask类
Future:  
    可以对具体的Runnable Callable任务的执行结果进行取消,查询是否完成,获取结果等
    FutureTask是Future接口的唯一实现类
    FutureTask同时扩展了Runnable Future接口,它既可以作为Runnable被线程执行,
    又可以作为Future得到Callable的返回值 

代码实现

 

  1.   //1 创建一个实现了Callable接口的实现类
  2.     //2 重写call()方法 执行的操作写在其中
  3.     //3 创建实现了Callable接口的实现类对象
  4.     //4 将实现类对象作为参数传递到FutureTask构造器中
  5.     //5 将FutureTask对象作为参数传入Thread类的对象的构造器中,启动线程
  6.     //6 可以获取call方法的返回值..    
  7.     
  8. class MyThread implements Callable{
  9.     @Override
  10.     public Object call() throws Exception {
  11.         int  num=0;
  12.         for (int i = 0; i < 100; i++) {
  13.             System.out.println(i);
  14.             num+=i;
  15.         }
  16.         return num;
  17.     }
  18. }    
  19.    
  20. public class Demo2 {
  21.     public static void main(String[] args) {
  22.         //需要执行call方法
  23.         MyThread my =new MyThread();
  24.         //可以获取线程执行完毕的结果,也可以作为参数传递给Thread
  25.         FutureTask futureTask=new FutureTask(my);
  26.         //启动线程
  27.         new Thread(futureTask).start();
  28.         try {
  29.          //get();
  30.          //返回值即为FutureTask构造方法参callable实现类重写的call()方法的返回值
  31.             Object num = futureTask.get();
  32.             System.out.println(num);
  33.         } catch (InterruptedException e) {
  34.             e.printStackTrace();
  35.         } catch (ExecutionException e) {
  36.             e.printStackTrace();
  37.         }
  38.     }
  39. }
  40.  
  41. /*注意:
  42. get();//不能在start方法之前调用 它获取的是线程结束之后的结果*/

三种实现方式的对比 :

                                                   优点                               缺点
实现Runnable接口      扩展性强,实现该接口的同时       编程相对复杂不能直接使用
,Callable接口               还可以继承其他的类                   Thread类中的方法

 

继承Thread类              编程相对简单,可以直接使用         可扩展性差
                                     Thread类中的方法                       

不能在继承其他类 
                    
开发中优先选择实现Runnable接口的方式
    1 实现的方式没有类的单继承的限制
    2 实现的方式更适合处理多个线程有共享数据的情况

 Thread的方法- 

-获取多线程对象

  1. //Thread 中静态方法
  2. //返回对当前正在执行的线程对象的引用。 结果就是当前正在执行的线程。
  3. public static Thread currentThread()   
  4.     
  5. Thread.currentThread().getName() 获取当前线程的名字 默认名(Thread-0/1/2...)
  6. Thread.currentThread().setName() 设置当前线程的名字  
  7.  
  8. public static void main(String[] args) {
  9.     //获取主线程名字
  10.     System.out.println(Thread.currentThread().getName());
  11.     //给主线程是指名字
  12.     Thread.currentThread().setName("主线程");
  13.     System.out.println(Thread.currentThread().getName());
  14.  
  15. }

-sleep 

  1. // 1秒=1000毫秒
  2. //使当前正在执行的线程停留（暂停执行）指定的毫秒数，这取决于系统定时器和调度程序的精度和准确性。
  3. //线程不会丢失任何显示器的所有权。
  4. //millis - 以毫秒为单位的睡眠时间长度 不能是负数 否则报错
  5. //通俗说法
  6. :让当前线程睡眠指定的m毫秒数,在指定的m毫秒时间内当前线程是阻塞状态
  7. public static void sleep(long millis)
  8.  
  9. //导致正在执行的线程以指定的毫秒数加上指定的纳秒数来暂停（临时停止执行），
  10. //这取决于系统定时器和调度器的精度和准确性。 线程不会丢失任何显示器的所有权。 
  11. //millis - 以毫秒为单位的睡眠时间长度 
  12. //nanos - 0-999999额外的纳秒睡眠 
  13. public static void sleep(long millis,int nanos) 
  14.     
  15. public class Demo1 {
  16.     public static void main(String[] args) throws InterruptedException 	   {
  17.         MyThread thread = new MyThread("线程一");
  18.         thread.start();
  19.     }
  20. }
  21.  
  22. class MyThread extends Thread {
  23.     @Override
  24.     public void run() {
  25.         for (int i = 1; i < 100; i++) {
  26.             System.out.println(Thread.currentThread().getName() + "---" 			+ i);
  27.             try {
  28.                 this.sleep(1000);//阻塞1秒 
  29.              //Thread类中run方法没有抛异常 那么重写的方法也不能抛异常只能自己处理
  30.             } catch (InterruptedException e) {
  31.                 e.printStackTrace();
  32.             }
  33.         }
  34.     }
  35.     public MyThread(String name) {
  36.         super(name);
  37.     }
  38. }

-线程的优先级 

线程调度:
多线程的并发运行:
    计计算机中的CPU在任意时刻只能执行一条机器指令,每个线程只有获得CPU的使用权才能执       行代码,各个线程轮流获得CPU的使用权,分别执行各自的任务. 
        
1 线程的调度模型有哪些
    分时调度模:所有线程轮流使用cpu的使用权,平均分配每个线程占用CPU的时间片
        时间片
             -  -   -   -  -  - 
    抢占式调度模型:优先让优先级高的线程使用CPU,如果线程的优先级相同,那么会随机选择一    个优先级高的线程获取的CPU时间片相对多一些
    
    
2 java的线程调度方式
    抢占式调度模型
    同优先级的线程组成先进先出对列(先到先得) 使用时间片策略
    高优先级的,使用优先调度的抢占式策略
    
3 如何设置当前线程的优先级 
    优先级分档 一共10档
        10表示最高优先级,1表示最低优先级
        //三个静态常量
        MAX_PRIORITY:10;
        MIN_PRIORITY:1
        NORM_PRIORITY:5  //默认优先级
    设置当前线程的优先级
        setPriority(int n);
        
    获取线程的优先值
        getPriority(); 默认5
        
注意点:
    >线程创建的时候继承父线程的优先级
    >低的优先级只是获得调度的概率低,并非一定是在高优先级线程之后才被调用

 代码演示:

  1. //优先级更高只是说明抢夺CPU时间片的几率更高并不是说一定先执行完毕
  2. public class Demo2 {
  3.     public static void main(String[] args) throws IOException, ClassNotFoundException, InterruptedException, ExecutionException {
  4.         //需要执行call方法
  5.         MyThread m1 = new MyThread();
  6.         //可以获取线程执行完毕的结果,也可以作为参数传递给Thread
  7.         FutureTask<String> ftt=new FutureTask(m1);
  8.         Thread t=new Thread(ftt,"飞机1");
  9.         t.setPriority(1);
  10.         System.out.println(t.getPriority());
  11.         t.start();
  12.  
  13.         MyThread m2 = new MyThread();
  14.         FutureTask<String> ftt2=new FutureTask(m2);
  15.         Thread t2=new Thread(ftt2,"大炮2");
  16.         System.out.println(t2.getPriority());//默认优先级是5
  17.         t2.start();
  18.         System.out.println(ftt.get());
  19.         //不能在start方法之前调用 它获取的是线程结束之后的结果
  20.  
  21.     }
  22. }
  23. class   MyThread implements Callable<String> {
  24.     @Override
  25.     public String call() throws Exception {
  26.         for (int i = 0; i < 100; i++) {
  27.            System.out.println(Thread.currentThread().getName()+"  "+i);
  28.         }
  29.         return "运行结束";//返回值表示线程运行完毕之后的结果 泛型表示返回值的类型
  30.     }
  31. }

-守护线程 

线程的分类有哪些?
    守护线程    
    用户线程(普通线程)
    
      1 几乎在每个方面都是相同的,唯一的区别是判断jvm何时离开
    2 守护线程是用来服务用户线程的, 通过在start()方法之前调用
        thread.setDaemon(true) 可以把一个用户线程变成一个守护线程
        
    3 java的垃圾回收就是一个典型的守护线程
    4 若是jvm中都是守护线程,当前jvm将退出 
    5 当普通线程执行完毕,守护线程就停止了
       (但不是立即停止在有限的时间片内还会在执行一会儿)

  1. //将此线程标记为daemon线程或守护线程。 
  2. //当运行的唯一线程都是守护进程线程时，Java虚拟机将退出。
  3. //线程启动前必须调用此方法
  4. //on - 如果是 true ，将此线程标记为守护线程 
  5. public final void setDaemon(boolean on)
  6.  
  7. //测试这个线程是否是守护线程。
  8. public final boolean isDaemon()
  9.  
  10.  
  11. public class Demo2 {
  12.     public static void main(String[] args) throws IOException, ClassNotFoundException, InterruptedException, ExecutionException {
  13.         MyThread m1 = new MyThread();
  14.         m1.setName("女神");
  15.         MyThread2 m2 = new MyThread2();
  16.         m2.setName("添狗");
  17.  
  18.         m2.setDaemon(true);//把第2个线程设置为守护线程
  19.         m1.start();
  20.         m2.start();
  21.     }
  22. }
  23.  
  24. class MyThread extends Thread {
  25.     @Override
  26.     public void run() {
  27.         for (int i = 0; i < 10; i++) {
  28.        System.out.println(Thread.currentThread().getName() + "  " + i);
  29.         }
  30.     }
  31. }
  32.  
  33. class MyThread2 extends Thread {
  34.     @Override
  35.     public void run() {
  36.         for (int i = 0; i < 100; i++) {
  37.        System.out.println(Thread.currentThread().getName() + "  " + i);
  38.         }
  39.     }
  40. }

线程安全问题-同步代码块 

什么是同步代码块?
    解决线程同步

特点:同步代码块默认情况下是打开的,只有当有一个线程进入了代码块去执行代码
        锁才会关闭,当线程执行完毕, 锁才会自动打开
        
    同步的好处和弊端:
        好处:解决了多线程的数据安全问题
        弊端:当线程很多时候,因为每个线程都会去判断同步上的锁
            这是很耗费资源的,无形中会降低程序的运行效率

代码演示:

  1. //实现了Runnable接口
  2. public class Demo1 {
  3.     public static void main(String[] args) {
  4.         MyThread myThread = new MyThread();
  5.         Thread t1 = new Thread(myThread,"窗口1");
  6.         Thread t2 = new Thread(myThread,"窗口2");
  7.         Thread t3 = new Thread(myThread,"窗口3");
  8.         t1.start();
  9.         t2.start();
  10.         t3.start();
  11.     }
  12. }
  13. class MyThread implements Runnable{
  14.     private int ticket=100;
  15.  
  16.     Object o=new Object();
  17.     @Override
  18.     public   void run() {
  19.         //Object o=new Object(); 放在这就不是同一个对象了
  20.         while (true){
  21.             synchronized(o){  
  22.                 //同步监视器 : 锁对象,任何一个类的对象都可以充当锁对象
  23.                 //要求多个线程 共用的是同一把锁  o 对象只是创建了一次  
  24.                 //用类对象也可以MyThread.class
  25.                 //这个锁只有当某个线程 把完整的过程执行完毕之后才会释放
  26.                 //o 也可以写this 当前对象其实指的就是 myThread
  27.                 //同步代码块 不能包含多了 也不能包含少了  
  28.                 //具体问题具体分析  如果包上循环这就有问题了
  29.                 if(ticket>0){
  30.                     try {
  31.                         Thread.sleep(100);
  32.                     } catch (InterruptedException e) {
  33.                         e.printStackTrace();
  34.                     }                                                    					 System.out.println(Thread.currentThread().
  35.                     getName()+" 正在卖出第"+ticket+"张票");
  36.                     ticket--;
  37.                 }else{
  38.                     break;
  39.                 }
  40.             }
  41.         }
  42.     }
  43. }

线程安全问题-锁对象唯一

  1. public class Java26 {
  2.     public static void main(String b[]) {
  3.         MyThread t1=new MyThread();
  4.         MyThread t2=new MyThread();
  5.         t1.setName("窗口1");
  6.         t2.setName("窗口2");
  7.         t1.start();
  8.         t2.start();
  9.     }
  10. }
  11. class MyThread extends Thread{
  12.     //private int ticketcount=100;
  13.     private static  int ticketcount=100;
  14.     private static  Object  o=new Object();
  15.     //两个对象共用一份数据,同样两个对象也要共用一个所对象
  16.  
  17.     @Override
  18.     public void run() {
  19.         while (true){
  20.             synchronized (o){//锁对象一定要唯一   
  21.                  if(ticketcount<=0){
  22.                      break;
  23.                  }else{
  24.                      try {
  25.                          Thread.sleep(100);
  26.                      } catch (InterruptedException e) {
  27.                          e.printStackTrace();
  28.                      }
  29.                      ticketcount--;
  30.                      System.out.println(Thread.currentThread().getName()+"卖出一张票,还剩下"+ticketcount+"票");
  31.                  }
  32.             }
  33.         }
  34.     }
  35. }

线程安全问题-同步方法 

  1. //实现了Runnable接口
  2. public class Demo1 {
  3.     public static void main(String[] args) {
  4.         MyThread myThread = new MyThread();
  5.         Thread t1 = new Thread(myThread, "窗口1");
  6.         Thread t2 = new Thread(myThread, "窗口2");
  7.         Thread t3 = new Thread(myThread, "窗口3");
  8.         t1.start();
  9.         t2.start();
  10.         t3.start();
  11.     }
  12. }
  13.  
  14. class MyThread implements Runnable {
  15.     private int ticket = 100;
  16.     @Override
  17.     public void run() {
  18.         while (true) {
  19.             show();
  20.             if (ticket == 0)
  21.                 break;
  22.         }
  23.     }
  24.     private synchronized void show() { //同步监视器是: this
  25.         if (ticket > 0) {
  26.             try {
  27.                 Thread.sleep(100);
  28.             } catch (InterruptedException e) {
  29.                 e.printStackTrace();
  30.             }
  31.             System.out.println(Thread.currentThread().getName() + " 正在卖出第" + ticket + "张票");
  32.             ticket--;
  33.         } 
  34.     }
  35. }
  36.  
  37. //继承与Thread类	
  38. public class Demo1 {
  39.     public static void main(String[] args) throws InterruptedException 		{
  40.         MyThread thread1 = new MyThread();
  41.         MyThread thread2 = new MyThread();
  42.         MyThread thread3 = new MyThread();
  43.         thread1.setName("窗口1");
  44.         thread2.setName("窗口2");
  45.         thread3.setName("窗口3");
  46.         thread1.start();
  47.         thread2.start();
  48.         thread3.start();
  49.     }
  50. }
  51.  
  52. class MyThread extends Thread {
  53.     private static int ticket = 200;
  54.  
  55.     @Override
  56.     public void run() {
  57.         while (true) {
  58.             show();
  59.             if (ticket == 0)
  60.                 break;
  61.         }
  62.     }
  63. 	//如果不加静态默认还是this  也就是窗口 1,2,3
  64.     private static synchronized void show() {
  65.     	//同步监视器是:MyThread.class
  66.         if (ticket > 0) {
  67.             try {
  68.                 Thread.sleep(100);
  69.             } catch (InterruptedException e) {
  70.                 e.printStackTrace();
  71.             }
  72.             System.out.println(Thread.currentThread().getName() + " 卖票, 号为:" + ticket);
  73.             ticket--;
  74.         }
  75.     }
  76. }	
  77. /*同步静态方法
  78. 	修饰符 static  synchronized 返回值类型 方法名(参数表){}
  79. 	
  80. 	同步静态方法的锁对象是: 类名.class  是类对象  (反射讲解)*/

线程安全问题- lock 锁

什么是lock锁
    从jdk1.5开始,java提供了更强大的线程同步机制 通过显示的定义同步锁对象来实现同步,  同步锁使用Lock对象充当 

  1. public class Java26 {
  2.     public static void main(String[] args) {
  3.         Ticket ticket = new Ticket();
  4.         Thread t1 = new Thread(ticket, "窗口1");
  5.         Thread t2 = new Thread(ticket, "窗口2");
  6.         Thread t3 = new Thread(ticket, "窗口3");
  7.         t1.start();
  8.         t2.start();
  9.         t3.start();
  10.     }
  11. }
  12.  
  13. class Ticket implements Runnable {
  14.     private int ticket = 100;
  15.     private ReentrantLock rtt = new ReentrantLock();
  16.  
  17.     @Override
  18.     public void run() {
  19.         while (true) {
  20.             try {
  21.                 //第一步 加锁  以下代码都被锁住
  22.                 rtt.lock();
  23.                 //synchronized (this) {
  24.                 if (ticket <= 0) {
  25.                     //如果票数为0表示卖完了
  26.                     break;//跳出循环
  27.                 } else {
  28.                     try {
  29.                         Thread.sleep(50);
  30.                     } catch (InterruptedException e) {
  31.                         e.printStackTrace();
  32.                     }
  33.                     ticket--;
  34.                     System.out.println(Thread.currentThread().getName() 					+ "卖出一张票,还剩下" + ticket + "票");
  35.                 }
  36.             } catch (Exception e) {
  37.                 e.printStackTrace();
  38.             } finally {
  39.                 //解锁
  40.                 rtt.unlock();
  41.             }
  42.         }
  43.     }
  44. }

synchronized和lock的区别

同: 二者都可以解决线程同步问题    
异: 
    synchronized  隐式锁 在执行完相应的同步代码之后,自动的释放锁对象  
    分为代码块锁 和方法锁
    
    lock 显示锁 需要手动的启动同步  结束同步也需要手动实现
    
    使用lock jvm将花费较少的时间来调度线程,性能更好,并且具有很好的拓展性(提供了更多的子类)

使用顺序  lock > 同步代码块 > 同步方法    

 死锁

1 什么是死锁
    1不同的线程分别占用着对方需要的同步资源不放弃,都在等待对方放弃自己需要的同步资源,
    2 死锁出现后,不会出现异常,不会出现提示,只是所有线程都处于阻塞状态,无法继续
    
2 死锁解决方案有哪些    
    1 专门的算法,原则
    2 尽量减少同步资源的定义
    3 尽量避免同步嵌套

  1. //代码演示
  2. public static void main(String[] args) {
  3.     StringBuilder s1=new StringBuilder();
  4.     StringBuilder s2=new StringBuilder();
  5.     new Thread(){
  6.         @Override
  7.         public void run() {
  8.                synchronized (s1){
  9.                    s1.append("a");
  10.                    s2.append("1");
  11.                    try {
  12.                        Thread.sleep(100);
  13.                    } catch (InterruptedException e) {
  14.                        e.printStackTrace();
  15.                    }
  16.                    synchronized (s2){
  17.                        s1.append("b");
  18.                        s2.append("2");
  19.                        System.out.println(s1);
  20.                        System.out.println(s2);
  21.                    }
  22.                }
  23.         }
  24.     }.start();
  25.  
  26.     new Thread(new Runnable() {
  27.         @Override
  28.         public void run() {
  29.             synchronized (s2){
  30.                 s1.append("c");
  31.                 s2.append("3");
  32.                 try {
  33.                     Thread.sleep(100);
  34.                 } catch (InterruptedException e) {
  35.                     e.printStackTrace();
  36.                 }
  37.                 synchronized (s1){
  38.                     s1.append("d");
  39.                     s2.append("4");
  40.                     System.out.println(s1);
  41.                     System.out.println(s2);
  42.                 }
  43.             }
  44.         }
  45.     }).start();
  46. }
  47.  
  48. /*有几种答案
  49.     ab
  50.     12
  51.     abcd
  52.     1234  
  53.     ----------
  54.     cd
  55.     34
  56.     cdab
  57.     3412
  58.     ---------
  59.     没有结果*/

最后分享一个生产者和消费者的小案例:

生产者和消费者模式:等待唤醒机制
生产者消费者模式是一个十分经典的多线程协作的模式.
    
    在软件开发过程中，有产生数据的代码模块，有处理数据的代码模块，
    在生产者和消费者模式中，产生数据的模块就称之为生产者，
    处理数据的模块就称之为消费者。
    还有一个存储区连接着生产者和消费者，生产者生产的数据放到存储区中，
    而消费者取数据也是从存储区中去取，这个存储区是有最大容量限制的，
    如果存储区中的数据达到了最大容量，那么就要让生产者暂停生产数据，
    等有容量了在进行生产。如果存储区中没有数据，
    那么就要让消费者暂停处理数据，等到有数据了在进行消费。
    生产者和消费者模式要解决的问题就是生产者和消费者之间处理数据的动态平衡问题。
    
例子:
    有一个生产者生产包子，他将生产好的包子放到筐中，
    放完包子由消费者从筐中拿出包子使用。
    当然筐还有一个作用就是当筐中没有包子时便锁住筐，不让消费者去筐中再拿取东西，
    当筐中有包子时，不让生产者再向筐中放入包子。    

  1. //导致当前线程等到另一个线程调用该对象的notify()方法或notifyAll()方法。 
  2. public final void wait()
  3. //导致当前线程等待，直到另一个线程调用此对象的notify()方法或notifyAll()方法，或指定的时间已过。 
  4. //timeout - 以毫秒为单位等待的最长时间。
  5. public final void wait(long timeout)
  6. //唤醒正在等待对象监视器的单个线程,如果任何线程正在等待这个对象，
  7. //其中一个被选择被唤醒。 选择是任意的，并且由实施的判断发生。
  8. public final void notify()
  9. //唤醒正在等待对象监视器的所有线程。 线程通过调用其中一个wait方法等待对象的监视器。 
  10. public final void notifyAll()
  11.  
  12. public class Java26 {
  13.     public static void main(String[] args) {
  14.         new Foodie().start();
  15.         new Cooker().start();
  16.     }
  17. }
  18. class Desk {
  19.     //定一个标记
  20.     //true就表示桌子上有汉堡,此时允许吃
  21.     //false表示桌子上没有汉堡,此时厨师应该去制作汉堡
  22.     public static boolean flag = false;
  23.     //售卖汉堡包的总数量
  24.     public static int count = 10;
  25.     //生产者和消费者公用一把锁对象
  26.     public static Object lock = new Object();
  27. }
  28. //消费
  29. class Foodie extends Thread {
  30.     @Override
  31.     public void run() {
  32.         while (true) {
  33.             synchronized (Desk.lock) {
  34.                 //判断桌子上是否有食物
  35.                 if(Desk.count==0){//判断今日限额是否售光
  36.                     break;
  37.                 }else{
  38.                     //判断是否已经有制作好的汉堡
  39.                     if(Desk.flag){
  40.                         //有 就消费
  41.                         System.out.println("吃完该汉堡包...");
  42.                         //吃完没有了
  43.                         Desk.flag=false;
  44.                         //叫醒厨师做
  45.                         Desk.lock.notifyAll();//叫醒所有等待的线程
  46.                         Desk.count--;//销售额-1
  47.                     }else{
  48.                         //没有等待 使用什么对象当锁,
  49.                         //那么就必须使用这个对象去掉用等待和唤醒的方法
  50.                         try {
  51.                             Desk.lock.wait();
  52.                         } catch (InterruptedException e) {
  53.                             e.printStackTrace();
  54.                         }
  55.                     }
  56.                 }
  57.             }
  58.         }
  59.     }
  60. }
  61. //生产者
  62. class Cooker extends  Thread{
  63.     @Override
  64.     public void run() {
  65.         while(true){
  66.             synchronized (Desk.lock){
  67.                 if(Desk.count==0){//判断今日限额是否售光
  68.                     break;//如果已经销售完了 退出
  69.                 }else{
  70.                     if(!Desk.flag){//还没有制作好
  71.                             //生产
  72.                         System.out.println("厨师正在制作.....");
  73.                         Desk.flag=true;
  74.                         //通知制作好了可以消费了
  75.                         Desk.lock.notifyAll();
  76.                     }else{
  77.                         try {
  78.                             //已经生产好了  等待消费者消费
  79.                             Desk.lock.wait();
  80.                         } catch (InterruptedException e) {
  81.                             e.printStackTrace();
  82.                         }
  83.                     }
  84.                 }
  85.             }
  86.         }
  87.     }
  88. }

 

 

 

 


 

 

 

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/凡人多烦事01/article/detail/560603
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号