黑马程序员——12，多线程（2）

最新推荐文章于 2024-02-07 18:51:50 发布
最新推荐文章于 2024-02-07 18:51:50 发布
阅读量839 收藏 2
点赞数
CC 4.0 BY-SA版权
分类专栏： 学习笔记 文章标签： 黑马程序员
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/dangaodeaiyi/article/details/47116129
本文详细介绍了多线程编程中的线程通信机制，包括使用同步代码块解决线程间的数据同步问题，通过等待唤醒机制实现精确的数据交互流程，并展示了如何利用JDK 1.5新增的Lock和Condition实现更高效的线程协调。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

------<ahref="http://www.itheima.com" target="blank">Java培训、Android培训、iOS培训、.Net培训</a>、期待与您交流！ -------

              黑马程序员——12，多线程（2）

 

//线程之间的通信
//就是多个线程操作同一个资源，操作动作不同
//举一个例子：一堆资源（名字，性别），一个线程输入，一个线程输出打印
 
class  Person
{
         String  name;
         String  sex;
}
 
class   Shuru  implements  Runnable            
{
     private  Person  p;
           Shuru( Person p   )
           {
               this.p=p;
           }
           public  void  run()
           {
                     int x= 0;
                     while(true)//特别说明：因为 while (true)这句话的关系，最后要按Ctrl+c按键才停下虚拟机，否则会耗费很多资源）        
                     {
            if(x==0)
                              {
               p.name="张三";
                          p.sex="男性";
                              }
                              else
                              {
               p.name="李四";
                          p.sex="女性";
                              }
                              x=(x+1)%2;
                     }
           }
}
class  Shuchu  implements  Runnable
{
           private Person  p;
           Shuchu( Person  p   )
           {
               this.p=p;
           }
            public  void  run()
           {
               while(true)
                     { 
                              System.out.println(p.name+"-----"+p.sex);
                     }
           }
 
}
 
class Xctx
{
         public  static  void  main(String[] args)
         {
                   Person  p=new Person();
 
                   Shuru  b1=new Shuru(p);
                   Shuchu  b2=new Shuchu(p);
 
                   Thread  c1=new Thread(b1);
                   Thread  c2=new Thread(b2);
 
                   c1.start();
             c2.start();
                   System.out.println("HelloWorld!");
         }
}
 
/*
按照一般的思路，准确的打印应该是张三对应男性，李四对应女性的
可是编译运行的结果如下，出了问题：
Hello World!
李四-----男性
李四-----男性
李四-----女性
李四-----男性
张三-----女性
张三-----女性
李四-----男性
李四-----男性
张三-----男性
张三-----女性
张三-----男性
张三-----男性
李四-----男性
张三-----男性
李四-----女性
李四-----男性
张三-----男性
李四-----女性
张三-----女性
李四-----女性
李四-----男性
 
 
出问题的原因是：输入线程在输入信息的同时输出线程也在打印，
那么很有可能在输入信息输入到一半的时候，就被输出线程打印出去了，
那么打印出去的就是部分更新数据部分旧数据，这就对应不上了
*/

——————分析——————

//为了解决这种问题，我们还是可以用同步代码块来解决
/*
原理就是输入线程与输出线程都是对同一个对象操作，只不过操作过程不一样
那么使用同步代码块，让两个使用同一个锁，这样就限制了在某一个时刻只能够有一个线程对对象进行操作
等这个线程操作完之后下一个线程才可以对对象进行操作
确保了打印出来的对象信息的更新是完整
*/
 
class  Person
{
         String  name;
         String  sex;
         static  Object obj=new Object();
}
 
class   Shuru  implements Runnable            
{
     private  Person  p;
           Shuru( Person p   )
           {
               this.p=p;
           }
           public  void run()
           {
                     int x= 0;
                     while(true)//特别说明：因为 while (true)这句话的关系，最后要按Ctrl+c按键才停下虚拟机，否则会耗费很多资源）
        
                     {
                              synchronized(Person.obj)//用的锁是obj
                              {
                if(x==0)
                                {
                  p.name="张三";
                             p.sex="男性";
                                }
                                else
                                {
                   p.name="李四";
                              p.sex="女性";
                                }
                                x=(x+1)%2;
                             }
                     }
           }
 
 
}
class   Shuchu  implements  Runnable
{
           private  Person   p;
           Shuchu( Person  p   )
           {
               this.p=p;
           }
            public void run()
           {
               while(true)
                     { 
                              synchronized(Person.obj)//用的锁是obj
                              {
                             System.out.println(p.name+"-----"+p.sex);
                              }
                     }
           }
 
}
 
class  Xctx2
{
         public  static  void  main(String[] args)
         {
                   Person  p=new Person();
 
                   Shuru  b1=new Shuru(p);
                   Shuchu  b2=new Shuchu(p);
 
                   Thread  c1=new Thread(b1);
                   Thread  c2=new Thread(b2);
 
                   c1.start();
             c2.start();
                   System.out.println("HelloWorld!");
         }
}

——————分析——————

</pre><pre name="code" class="java">//线程通信中的等待唤醒机制的例子
 
/*
等待唤醒机制，简单的说法就是
用一个标示（一般是Boolean型的变量）
true标记输入线程操作，而false标记输出线程操作
输入线程操作时候，输出线程冻结状态
输出线程操作时候，输入线程冻结状态
这样来保证输出结果的准确性
这就需要用到wait()和notify()  或者是notifyAll()
*/
class  Person
{
         String  name;
         String  sex;
         static  Object obj=new Object();
         boolean  bs=true;//设定一个标示
}
 
class   Shuru  implements Runnable            
{
     private  Person  p;
           Shuru( Person p   )
           {
               this.p=p;//接收一个Person类的对象，就指向该对象，该写法更加方便
           }
           public  void  run()
           {
                     int x= 0;
                     while(true)
//特别说明：因为 while (true)这句话的关系，最后要按Ctrl+c按键才停下虚拟机，否则会耗费很多资源）
        
                     {
                              synchronized(Person.obj)//用的锁是obj
                              {
                if(!p.bs)
                                       {
                                               try{Person.obj.wait();}catch(Exception e){}
                                       }
                                               //wait()方法可以冻结线程,该方法是定义在Object类的
                                               /*
                               这里为什么不直接用wait()呢？
                               因为wait()方法会抛出一个异常所以要用try...catch
                               为什么这里还要在wait前面加上Person.obj这个锁呢？
                               因为这种写法：锁.wait();   -----表示持有该锁的线程要陷入沉睡。
                               也是因为这个原因，wait()方法必须在同步中才可以用，而notify() 
                               和notifyAll()也是因为以上原因在同步中才可以用。
                               其写法也是：  锁.notify();或者是  锁.notifyAll();
                  
                                               */
                if(x==0)
                                {
                  p.name="张三";
                             p.sex="男性";
                                }
                                else
                                {
                  p.name="李四";
                              p.sex="女性";
                                }
                                x=(x+1)%2;
                Person.obj.notify();
                                     /*
                                     陷入沉睡的线程都会被扔进线程池
                                     notify()方法功能是唤醒在在线程池中头一个沉睡的线程
                                     而notifyAll()方法则是唤醒所有沉睡的线程
                                     */
                 p.bs=false;
                             }
                     }
           }
 
 
}
class   Shuchu  implements  Runnable
{
           private  Person   p;
           Shuchu( Person  p   )
           {
               this.p=p;
           }
            public  void  run()
           {
               while(true)
                     { 
                              synchronized(Person.obj)//用的锁是obj
                              {
                                       if(p.bs)
                                       {
                                                 try{Person.obj.wait();} catch(Exception e){}
                                       }
                                    
                   
                                 System.out.println(p.name+"-----"+p.sex);
                                       Person.obj.notify();
                  p.bs=true;
                              }
                     }
           }
 
}
 
class Xctx3
{
         public  static void main(String[] args)
         {
                   Person  p=new Person();
 
                   Shuru  b1=new Shuru(p);
                   Shuchu  b2=new Shuchu(p);
 
                   Thread  c1=new Thread(b1);
                   Thread  c2=new Thread(b2);
 
                   c1.start();
             c2.start();
                   System.out.println("HelloWorld!");
         }
}
/*
以上程序编译运行结果是：
Hello World!
张三-----男性
李四-----女性
张三-----男性
李四-----女性
张三-----男性
李四-----女性
张三-----男性
李四-----女性
张三-----男性
李四-----女性
张三-----男性
李四-----女性
张三-----男性
李四-----女性
 
*/


补充：对于非静态的synchronized方法，其锁默认为this

           对于静态的synchronized方法，其锁默认：为该方法所在类的类名.class     

         对于同步代码块，其锁就是括号内的东西。

——————分割线————————

//以下是代码优化之后的程序，更加简洁明了
class  Person
{
         private  String  name;
         private  String  sex;
        
         private  boolean  bs=true;//设定一个标示
         public  synchronized  void  set( String name,String  sex   )//写入资料的方法
         {
                   if(!bs)
                   {       
                            try{this.wait();}catch(Exception e){}
                   }
                                    
              this.name=name;
                    this.sex=sex;
                    bs=false;
                     this.notify();
         }
         public  synchronized  void  out()//打印资料的方法
         {
         if(bs)
                   {       
                            try{this.wait();}catch(Exception e){}
                   }
            System.out.println("输出的是----"+name+"---"+sex);
                    bs=true;
                    this.notify();
         }
}
 
class   Shuru  implements  Runnable            
{
     private  Person  p;
           Shuru( Person p   )
           {
               this.p=p;
           }
           public  void  run()
           {
                     int x= 0;
                     while(true)//特别说明：因为 while (true)这句话的关系，最后要按Ctrl+c按键才停下虚拟机，否则会耗费很多资源）
        
                     {
          
               if(x==0)
                   p.set("张三","男性");
                                else
                    p.set("李四","女性");
                              
                                     x=(x+1)%2;
                           
                     }
           }
 
 
}
class  Shuchu  implements  Runnable
{
           private Person  p;
           Shuchu( Person  p   )
           {
               this.p=p;
           }
            public void run()
           {
               while(true)
                     {
                            p.out();
                     }
           }
 
}
 
class  Xctx4
{
         public  static  void  main(String[] args)
         {
                   Person  p=new Person();
 
                   newThread(new Shuru(p)).start();
             new Thread(new Shuchu(p)).start();
 
                   System.out.println("HelloWorld!");
/*
                   Shuru  b1=new Shuru(p);
                   Shuchu  b2=new Shuchu(p);
 
                   Thread  c1=new Thread(b1);
                   Thread  c2=new Thread(b2);
 
                   c1.start();
             c2.start();
                   System.out.println("HelloWorld!");
*/
         }
}

————————分割线——————

/*
多线程的常见生活例子
有多个生产者生产食品，有多个消费者消化食品
每生产一个食品就消费一个食品
*/
 
class  Shipin
{
         private  int  sp=0;
         private   boolean   f=true;
         public  synchronized  void  shengchang(  )
         {
                   while(true)
                   {
        
                    while(f==false)//注意这里用的是while所以每次线程从冻结状态醒来都要检查一次f是否是false
                       try{this.wait();} catch(Exception e){}
        sp++;
              System.out.println("生产者"+Thread.currentThread().getName()+"----"+sp);
                  
                    f=false;
                    this.notifyAll();
                    /*
                       这里用notifyAll()方法就是为了让所有沉睡的线程醒来
          既唤醒了生产者又唤醒了消费者
          此时如果f=true那么由于之前的while作用，消费者即使是得到权限（锁）也不能执行只能冻结，所以只有一个生产者可以得到权限执行。
         此时如果是f=false那么由于之前的while作用，生产者即使是得到权限（锁）也不能执行只能冻结所以只有一个消费者可以得到权限执行。
                    */
                   }
                  
         }
         public  synchronized  void  xiaofei(   )
         {
                   while(true)
                   {
                     while(f==true)
                       try{this.wait();} catch(Exception e){} 
 
                System.out.println("消费者"+Thread.currentThread().getName()+"----"+sp);
                  
                      f=true;
                      this.notifyAll();
                   }
         }
}
class  Shengchangzhe  implements  Runnable
{
         private  Shipin   a ;
         Shengchangzhe(Shipin   a)
         {
             this.a=a;
         }
   public void run()
         {
              a.shengchang();     
         }
}
 
class  Xiaofeizhe  implements  Runnable
{
   private  Shipin   a ;
         Xiaofeizhe(Shipin   a)
         {
             this.a=a;
         }
   public  void run()
         {
              a.xiaofei();     
         }
}
class   Xctx5
{
         public  static  void  main(String[] args)
         {
                   Shipin  a=new Shipin();
 
                   Shengchangzhe  b1=new Shengchangzhe(a);
                   Shengchangzhe  b2=new Shengchangzhe(a);
                   Xiaofeizhe     b3=new Xiaofeizhe(a);
       Xiaofeizhe     b4=newXiaofeizhe(a);
 
                   Thread  t1=new Thread(b1);
                Thread  t2=new Thread(b2);
             Thread t3=new Thread(b3);
                   Thread  t4=new Thread(b4);
 
       t1.start();
       t2.start();
             t3.start();
             t4.start();
                   System.out.println("HelloWorld!");
         }
}
/*
以上程序编译运行结果如下：
生产者Thread-0----1
Hello World!
消费者Thread-3----1
生产者Thread-1----2
消费者Thread-2----2
生产者Thread-0----3
消费者Thread-3----3
生产者Thread-1----4
消费者Thread-2----4
生产者Thread-0----5
消费者Thread-3----5
生产者Thread-1----6
消费者Thread-2----6
生产者Thread-0----7
消费者Thread-3----7
生产者Thread-1----8
消费者Thread-2----8
生产者Thread-0----9
消费者Thread-3----9
生产者Thread-1----10
消费者Thread-2----10
生产者Thread-0----11
消费者Thread-3----11
生产者Thread-1----12
消费者Thread-2----12
生产者Thread-0----13
消费者Thread-3----13
生产者Thread-1----14
消费者Thread-2----14
生产者Thread-0----15
消费者Thread-3----15
生产者Thread-1----16
消费者Thread-2----16
生产者Thread-0----17
消费者Thread-3----17
生产者Thread-1----18
消费者Thread-2----18
生产者Thread-0----19
消费者Thread-3----19
生产者Thread-1----20
消费者Thread-2----20
生产者Thread-0----21
消费者Thread-3----21
生产者Thread-1----22
消费者Thread-2----22
生产者Thread-0----23
消费者Thread-3----23
生产者Thread-1----24
消费者Thread-2----24
生产者Thread-0----25
消费者Thread-3----25
生产者Thread-1----26
消费者Thread-2----26
生产者Thread-0----27
消费者Thread-3----27
生产者Thread-1----28
消费者Thread-2----28
生产者Thread-0----29
消费者Thread-3----29
生产者Thread-1----30
消费者Thread-2----30
生产者Thread-0----31
*/

——————分割线————

 

//另外一个是jdk1.5版本升级后的情况：
import java.util.concurrent.locks.*;
//这个导入的是后面需要用到的类
 
/*
随着jdk1.5版本的升级，一些新的功能也被加入，更加的方便使用者
就拿多线程通信的生产者消费者例子来说
*/
 
class   Xctx6
{
         public  static  void  main(String[] args)
         {
                   Shipin  a=new Shipin();
 
                   Shengchangzhe  b1=new Shengchangzhe(a);                
                   Xiaofeizhe     b2=new Xiaofeizhe(a);     
 
                   Thread  t1=new Thread(b1);
                   Thread  t2=new Thread(b1);
                   Thread t3=new Thread(b2);
                   Thread  t4=new Thread(b2);
 
             t1.start();
             t2.start();
             t3.start();
             t4.start();
                   System.out.println("HelloWorld!");
         }
}
class   Shipin
{
         private  int sp=0;
         private  boolean  f=true;
         private  Lock   lock=new   ReentrantLock();//将锁作为一个对象了
 
   private  Condition  pro= lock.newCondition();
   private  Condition  con= lock.newCondition();
   /*
             Condition将Object监视器（锁）的方法（wait，notify，notifyAll）分解成不同的对象，
                   这是为了便于与Lock组合使用。
       Lock代替synchronized方法和语句的使用（同步函数和同步代码块）
                   Condition替代了Object监视器（锁）的方法的使用。
                   Condition实例是绑定在锁上的，一个Lock实例要获得Condition实例就要调用newCondition方法。
         */
         public    void  shengchang() throws  InterruptedException 
         {
                   lock.lock();
                   try
                   {
                    while(f==false)
                      pro.await();//生产者线程陷入冻结
                    //这个句式会抛出一个InterruptedException异常
        sp++;
             System.out.println("生产者"+Thread.currentThread().getName()+"----"+sp);
                  
                    f=false;
                    con.signal();//仅仅唤醒消费者线程
                   }
                   finally
                   {
                        lock.unlock();//释放锁
                   }
                   /*
                   这里是所以要使用try...finally句型是因为确保
                   一定要执行 lock.unlock();也是因为前面的pro.await();会向外抛出
                   一个异常，如果没有这个句型程序就会跳出去而没有
                   执行lock.unlock();这样的话线程就没有释放锁
        */           
                  
         }
         public  void  xiaofei() throws InterruptedException 
         {
                   lock.lock();
                   try
                   {
 
                     while(f==true)
                       con.await();//消费者线程陷入冻结
                System.out.println("消费者"+Thread.currentThread().getName()+"----"+sp);
                      f=true;
                      pro.signal();//唤醒生产者线程
                   }
                   finally
                   {
                     lock.unlock();
                   }
         }
}
class   Shengchangzhe  implements  Runnable
{
         private  Shipin   a ;
         Shengchangzhe(Shipin   a)
         {
             this.a=a;
         }
   public  void  run()
         {
                   while(true)
                   {
                     try{a.shengchang();}
                     catch(Exception e){}
                   }
         }
}
 
class  Xiaofeizhe  implements  Runnable
{
   private  Shipin   a ;
         Xiaofeizhe(Shipin   a)
         {
             this.a=a;
         }
   public  void  run()
         {
                   while(true)
                   {
                     try{a.xiaofei();}
                     catch(Exception e){}
                   }
         }
}

/*

对前面的例子做了一个改进：

有生产者，检查者，消费者

先要由生产者生产食品，

然后由检查者检测食品，

最后由消费者消化食品。

*/

import java.util.concurrent.locks.*;
 
class  Xctx7
{
         public  static  void  main(String[] args)
         {
                   Shipin  a=new Shipin();
 
                   Shengchangzhe  b1=new Shengchangzhe(a);                
                   Xiaofeizhe     b2=new Xiaofeizhe(a);
                   Jiancezhe      b3=new Jiancezhe(a);
 
                   Thread  t1=new Thread(b1);
                   Thread  t2=new Thread(b1);
                   Thread t3=new Thread(b2);
                   Thread  t4=new Thread(b2);
                   Thread t5=new Thread(b3);
                   Thread  t6=new Thread(b3);
 
 
             t1.start();
             t2.start();
             t3.start();
             t4.start();
             t5.start();
             t6.start();
                   System.out.println("HelloWorld!");
         }
}
class   Shipin
{
         private  int sp=0;
         private  int  f=1;
         private  Lock lock=new ReentrantLock();//将锁作为一个对象了
 
   private  Condition  pro= lock.newCondition();
   private  Condition  con= lock.newCondition();
   private  Condition  jc = lock.newCondition();
 
         public    void shengchang() throws InterruptedException 
         {
                   lock.lock();
                   try
                   {
                    while(f!=1)
                             {
                             pro.await();//生产者线程陷入冻结
                             }
                    
        sp++;
              System.out.println("生产者"+Thread.currentThread().getName()+"----"+sp);
                  
                    f=2;
                   jc.signal();//唤醒检测者线程
                   }
                   finally
                   {
                        lock.unlock();//释放锁
                   }       
                  
         }
         public  void  xiaofei() throws   InterruptedException 
         {
                   lock.lock();
                   try
                   {
 
                     while(f!=3)
                            {
                       con.await();//消费者线程陷入冻结
                            }
                           
                System.out.println("消费者"+Thread.currentThread().getName()+"----------"+sp);
                      f=1;
                      pro.signal();//唤醒生产者线程
                   }
                   finally
                   {
                     lock.unlock();
                   }
         }
   public  void  jiance() throws  InterruptedException  //检测方法
         {
                   lock.lock();
                   try
                   {
 
                     while(f!=2)
                            {
                       jc.await();//检测者线程陷入冻结
                           
                            }
                System.out.println("检测者"+Thread.currentThread().getName()+"-------"+sp);
                      f=3;
                      con.signal();//唤醒消费者线程
                   }
                   finally
                   {
                     lock.unlock();
                   }
         }
 
}
class   Shengchangzhe  implements  Runnable
{
         privateShipin   a ;
         Shengchangzhe(Shipin   a)
         {
             this.a=a;
         }
   public   void   run()
         {
                   while(true)
                   {
                     try{a.shengchang();}
                     catch(Exception e){}
                   }
         }
}
 
class   Xiaofeizhe  implements   Runnable
{
   private   Shipin   a ;
         Xiaofeizhe(Shipin   a)
         {
             this.a=a;
         }
   public  void  run()
         {
                   while(true)
                   {
                     try{a.xiaofei();}
                     catch(Exception e){}
                   }
         }
}
class   Jiancezhe  implements Runnable
{
   private   Shipin   a ;
         Jiancezhe(Shipin   a)
         {
             this.a=a;
         }
   public   void   run()
         {
                   while(true)
                   {
                     try{a.jiance();}
                     catch(Exception e){}
                   }
         }
}
/*
以上的代码编译运行结果如下：
生产者Thread-0----1
Hello World!
检测者Thread-4-------1
消费者Thread-3----------1
生产者Thread-0----2
检测者Thread-5-------2
消费者Thread-3----------2
生产者Thread-1----3
检测者Thread-5-------3
消费者Thread-2----------3
生产者Thread-0----4
检测者Thread-4-------4
消费者Thread-3----------4
生产者Thread-1----5
检测者Thread-5-------5
消费者Thread-2----------5
生产者Thread-0----6
检测者Thread-4-------6
消费者Thread-3----------6
生产者Thread-1----7
检测者Thread-5-------7
消费者Thread-2----------7
生产者Thread-0----8
检测者Thread-4-------8
消费者Thread-3----------8
生产者Thread-1----9
检测者Thread-5-------9
消费者Thread-2----------9
生产者Thread-0----10
检测者Thread-4-------10
消费者Thread-3----------10
生产者Thread-1----11
检测者Thread-5-------11
消费者Thread-2----------11
生产者Thread-0----12
检测者Thread-4-------12
消费者Thread-3----------12
生产者Thread-1----13
检测者Thread-5-------13
消费者Thread-2----------13
生产者Thread-0----14
检测者Thread-4-------14
消费者Thread-3----------14
生产者Thread-1----15
检测者Thread-5-------15
消费者Thread-2----------15
生产者Thread-0----16
检测者Thread-4-------16
消费者Thread-3----------16
生产者Thread-1----17
检测者Thread-5-------17
消费者Thread-2----------17
生产者Thread-0----18
检测者Thread-4-------18
消费者Thread-3----------18
生产者Thread-1----19
检测者Thread-5-------19
消费者Thread-2----------19
生产者Thread-0----20
检测者Thread-4-------20
消费者Thread-3----------20
生产者Thread-1----21
检测者Thread-5-------21
消费者Thread-2----------21
生产者Thread-0----22
检测者Thread-4-------22
消费者Thread-3----------22
生产者Thread-1----23
检测者Thread-5-------23
消费者Thread-2----------23
生产者Thread-0----24
检测者Thread-4-------24
消费者Thread-3----------24
生产者Thread-1----25
检测者Thread-5-------25
消费者Thread-2----------25
生产者Thread-0----26
检测者Thread-4-------26
消费者Thread-3----------26
生产者Thread-1----27
检测者Thread-5-------27
消费者Thread-2----------27
生产者Thread-0----28
检测者Thread-4-------28
消费者Thread-3----------28
生产者Thread-1----29
检测者Thread-5-------29
消费者Thread-2----------29
生产者Thread-0----30
检测者Thread-4-------30
消费者Thread-3----------30
生产者Thread-1----31
检测者Thread-5-------31
消费者Thread-2----------31
生产者Thread-0----32
检测者Thread-4-------32
消费者Thread-3----------32
生产者Thread-1----33
检测者Thread-5-------33
消费者Thread-2----------33
生产者Thread-0----34
检测者Thread-4-------34
消费者Thread-3----------34
生产者Thread-1----35
检测者Thread-5-------35
消费者Thread-2----------35
生产者Thread-0----36
检测者Thread-4-------36
消费者Thread-3----------36
生产者Thread-1----37
检测者Thread-5-------37
消费者Thread-2----------37
生产者Thread-0----38
检测者Thread-4-------38
消费者Thread-3----------38
生产者Thread-1----39
检测者Thread-5-------39
消费者Thread-2----------39
生产者Thread-0----40
检测者Thread-4-------40
消费者Thread-3----------40
生产者Thread-1----41
检测者Thread-5-------41
消费者Thread-2----------41
生产者Thread-0----42
检测者Thread-4-------42
消费者Thread-3----------42
生产者Thread-1----43
检测者Thread-5-------43
消费者Thread-2----------43
生产者Thread-0----44
检测者Thread-4-------44
消费者Thread-3----------44
生产者Thread-1----45
检测者Thread-5-------45
消费者Thread-2----------45
生产者Thread-0----46
检测者Thread-4-------46
消费者Thread-3----------46
生产者Thread-1----47
检测者Thread-5-------47
消费者Thread-2----------47
生产者Thread-0----48
检测者Thread-4-------48
消费者Thread-3----------48
生产者Thread-1----49
检测者Thread-5-------49
消费者Thread-2----------49
生产者Thread-0----50
检测者Thread-4-------50
消费者Thread-3----------50
生产者Thread-1----51
检测者Thread-5-------51
消费者Thread-2----------51
生产者Thread-0----52
检测者Thread-4-------52
消费者Thread-3----------52
生产者Thread-1----53
检测者Thread-5-------53
消费者Thread-2----------53
生产者Thread-0----54
检测者Thread-4-------54
消费者Thread-3----------54
生产者Thread-1----55
检测者Thread-5-------55
消费者Thread-2----------55
生产者Thread-0----56
检测者Thread-4-------56
消费者Thread-3----------56
生产者Thread-1----57
检测者Thread-5-------57
消费者Thread-2----------57
生产者Thread-0----58
检测者Thread-4-------58
消费者Thread-3----------58
生产者Thread-1----59
检测者Thread-5-------59
消费者Thread-2----------59
生产者Thread-0----60
检测者Thread-4-------60
消费者Thread-3----------60
生产者Thread-1----61
检测者Thread-5-------61
消费者Thread-2----------61
生产者Thread-0----62
检测者Thread-4-------62
消费者Thread-3----------62
生产者Thread-1----63
检测者Thread-5-------63
消费者Thread-2----------63
*/

黑马程序员——java多线程
serge666的博客
12-12 427
——- android培训、java培训、期待与您交流！ ———-什么是进程？ Ctrl+Shift+Esc 打开windows任务管理器 进程是操作系统动态执行和资源分配的一个基本单元，就是程序执行的过程，在这个过程中会占用内存空间和CPU资源。在操作系统中，程序的体现就是进程。一个程序至少有一个进程，一个复杂的应用程序可能启动并使用多个进程，例如谷歌Chrome浏览器、腾讯的QQ等采用的就是多
黑马程序员——多线程-整理笔记
nanfp的博客
07-06 1060
------Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ ------- 多线程的概念：           首先介绍什么是进程：进程是正在执行的程序，每个进程执行都有一个执行顺序，该顺序是一个执行路径，或者叫一个控制单元           线程是其实就是进程中一个独立的控制单元，线程在控制着执行，一个进程至少有一个线程。 线程和进程的不同：  
【Java并发编程】生产者消费者模式-上篇
fxkcsdn的博客
01-18 781
在实际的软件开发过程中，经常会碰到如下场景：某个模块负责产生数据，这些数据由另一个模块来负责处理（此处的模块是广义的，可以是类、函数、线程、进程等）。产生数据的模块，就形象地称为生产者；而处理数据的模块，就称为消费者。 单单抽象出生产者和消费者，还够不上是生产者／消费者模式。该模式还需要有一个缓冲区（也称之为仓库）处于生产者和消费者之间，作为一个中介。生产者把数据放入缓冲区，而消费者从缓冲区取出...
黑马程序员——Java多线程
daiqingmingg的博客
10-19 433
------http://www.itheima.com" target="blank">Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ ------- 一 . 线程和进程       进程：一个内存中运行的程序       线程：（1）线程是为了实现多任务，提供效率而出现的一个产物。进程中的一个执行流程，一个进程中可以运行                
黑马程序员——多线程
Jack.Han的博客
08-20 716
------Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ ------- 一、多线程的概述               多线程：就是指应用程序有多条执行路径。              进程：正在运行的应用程序。              线程：进程的执行单元，一条执行路径。                      注意：线程不能脱离进程而单独存在也就
黑马程序员——多线程2
dynasty110的博客
08-01 443
------- android培训、java培训、期待与您交流！ ---------- 接着上回的来 线程间通信涉及的方法 多个线程在处理统一资源，但是任务却不同，这时候就需要线程间通信。 等待/唤醒机制涉及的方法： 1. wait()：让线程处于冻结状态，被wait的线程会被存储到线程池中。 2. notify()：唤醒线程池中的一个线程。 3. notifyAll ()：唤醒
黑马程序员——Java 多线程
毒匠的专栏
09-01 731
------- android培训、java培训、期待与您交流！ ---------- Java网络编程 ------- android培训、java培训、期待与您交流！ ----------
黑马程序员——多线程笔记
weizhilin046的博客
12-12 618
------- android培训、java培训、期待与您交流！ ---------- 一、概念 进程：正在运行中的程序。一般在任务管理器中可以看到有很多正在执行的程序。CPU在快速的切换执行这些进程，CPU在一个时刻只执行一个进程 线程：就是进程中的独立控制单元，控制程序的运行。一个进程肯定至少有一个线程，当线程执行完后，这个进程（程序）也就执行完了 多线程：就是一个进程里面有两个以上的
黑马程序员———多线程
有你有我走天下
05-07 303
——- android培训、java培训、期待与您交流！ ———- 进程：是一个正在执行中的程序。每一个进程执行都有一个执行顺序，该顺序是一个执行路径，或者叫一个控制单元。线程：就是进程中的一个独立的控制单元。线程在控制着进程的执行。一个进程中至少有一个线程。创建线程的第一种方式：继承Thread类。步骤：1、定义类继承Thread.2、复写Thread类中的run方法。目的：将自定义方法存储在r
黑马程序员————多线程2（day12）
u010201862的专栏
08-31 446
---------------------- ASP.Net+Android+IO开发S、.Net培训、期待与您交流！ ----------------------     多线程2 l  线程间通信 – 等待唤醒机制 l  线程间通信- 生产者消费者 l  停止线程 l  join方法   线程间通信 – 等待唤醒机制 线程间通信： 其实就是多个线程在操作
黑马程序员入学Java知识——精华总结.doc
05-09
Java内置了对多线程的支持，通过Thread类或实现Runnable接口可以创建并管理多个执行线程。 17. **网络编程**： Java提供了丰富的API进行网络通信，如Socket和ServerSocket类，用于客户端和服务器之间的连接。 ...
黑马程序员 安卓学院 万元哥项目经理 分享220个代码实例
10-07
|--利用FinalHttp实现多线程断点续传 |--加密之MD5 |--动画Animation详解 |--动画之view左右抖动 |--动画之移动动画 |--动画之组合动画 |--动画之缩放动画ScaleAnimation |--反序列化对象 |--发送短信 读天气 调音量...
黑马程序员——java基础——多线程的学习总结
黑马程序员——ItBin2015的博客
07-21 2898
android培训、java培训期待与您交流！ 进程：是一个正在执行中的程序。每一个进程执行都有一个执行顺序。该顺序是一个执行路径，或者叫一个控制单元。 线程：就是进程中的一个独立的控制单元(线程就是进程的一个执行路径)。线程在控制着进程的执行。 多线程则扩展了多进程的概念，使得同一个进程可以同时并发处理多个任务。线程(Thread )也被称作轻量级进程(Lightweight Proc
黑马程序员——瑞吉外卖项目解析（6）
最新发布
wn030416的博客
02-07 372
【代码】黑马程序员——瑞吉外卖项目解析（6）
win10调节屏幕亮度
dangaodeaiyi的专栏
02-25 1423
鼠标右键-》NVIDIA控制面板-》调整桌面颜色设置-》使用NVIDIA设置，就可以调节亮度，对比度等等
黑马程序员——11，多线程，同步函数，死锁，一些零散的小知识点
dangaodeaiyi的专栏
07-28 718
黑马程序员——11，多线程，同步函数，死锁，一些零散的小知识点 //同步函数   class  A                      {          intsum;          publicsynchronized void add
黑马程序员—— 6，多态
dangaodeaiyi的专栏
07-21 663
------Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ -------               黑马程序员——  6，多态 /*    关于多态的介绍    多态：事物的多种体现形式    动物：猫，狗   Cat a=new Cat();   Dongwu a=new Dongwu(); */   abstract class  P
javaScript和json例题
dangaodeaiyi的专栏
09-24 635
1，制作一个点名器： 点名器.html --> body{ background:url("../tu/8.11练习.png"); /* 可以自己选择背景图片 */ background:blue; } spa
黑马程序员多线程练习题
08-23
- *1* *2* *3* [黑马程序员——多线程10：多线程相关练习](https://blog.youkuaiyun.com/axr1985lazy/article/details/48186039)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":...
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值