多线程

多线程

 

进程：是一个正在执行中的程序。每一个进程执行都有一个执行顺序。该顺序是一个执行路径，或者叫一个控制单元。

线程：就是进程中的一个独立的控制单元。线程在控制着进程的执行。

一个进程中，至少有一个线程。

主线程：Java虚拟机启动的时候就会有一个进程java.exe。该进程中至少一个线程负责java程序的执行。而且这个线程运行的代码存在于main方法中。该线程称之为主线程。

扩展：

其实更细节说明虚拟机（jvm），jvm启动不止一个线程，还有负责垃圾回收的线程

 

如何在自定义的代码中，自定义一个线程呢？

通过对API的查找，java已经提供了对线程这类事物的描述。就是Thread类。

创建线程的第一种方式：继承Thread类。（通过查API表查到的）

步骤：

1、定义类继承Thread。

2、复写Thread类中的run方法。

目的：将自定义的代码存储在run方法中，让线程运行。

不覆写的话，运行的就是Thread类中的run方法。

3、调用线程的start方法。

该方法有两个作用：启动线程，调用run方法。

注意：其实，创建对象就是创建一个线程；调用这个对象的方法才是真正的启动这个线程。

Thread类用于描述线程。该类就定义一个功能，用于存储线程要运行的代码。该功能就是run方法。也就是说Thread类中的run方法，用于存储线程要运行的代码。

注意：运行结果每一次都不同。

因为多个线程都在获取CPU的执行使用权。CPU执行到哪个程序，该程序就运行。

明确一点，在某一时刻，只能有一个程序在运行。（多核除外）

其实是CPU在做着快速的切换，以达到看上去是同时运行的效果。

我们可以形象的把多线程的运行认为是在互相抢夺CPU的执行使用权。

这就是多线程的一个特性：随机性。

哪个程序先抢到就先执行，至于执行多长，CPU说了算。

创建线程的第二种方式：实现Runnable接口

步骤：

1、定义类实现Runnable 接口

2、覆盖Runnable 接口中的run方法

将线程要运行的代码存放在该run方法中。

3、通过Thread类建立线程对象

4、将Runnable接口的子类对象作为实际参数传递给Thread类的构造函数

为什么要将Runnable接口的子类对象传递给Thread类的构造函数？

因为，自定义的run方法所属的对象是Runnable接口的子类对象。所以要让线程去指定 指定对象 的run方法，就必须明确该run方法所属对象。

5、调用Thread类的start方法开启线程并调用Runnable接口子类的run方法

 

实现方式和继承方式的区别：

继承Thread：  线程代码存放在Thread子类的run方法中。

实现Runnable：线程代码存放在接口的子类的run方法中。

实现方式好处：避免了单继承的局限性。在定义线程时，建议使用实现的方式

 

多线程的安全问题：

问题原因：

当多条语句在操作同一个线程共享数据时，一个线程对多条语句只执行了一部分，还没执行完，另一个线程参与进来执行，导致共享数据的错误。

解决办法：

对多条操作共享数据的语句，只能让一个线程都执行完，在执行过程中，其他线程不可以参与执行。

JAVA对于多线程的安全问题，提供了专业的解决方式：就是同步代码块。

格式：

synchronized（对象）

{

需要被同步的代码块

}

 

*需要被同步的代码块：看哪些数据在操作共享数据，就属性需要被同步的代码块

对象如同锁。持有锁的线程可以在同步中执行。

没有持有锁的线程即使获取了CPU的执行权，也进不去，因为没有获取锁。

 

同步的前提：

1、必须要有两个或者两个以上的线程。

2、必须是多个线程使用同一个锁。

同步的好处：解决了多线程的安全问题

同步的弊端：多个线程都需要判断锁，较为消耗资源。当然，这个资源是在允许的范围内。

必须保证同步中只有一个线程在运行。把run方法中的代码全部放在同步中，那就使得代码变成了单线程。

 

在程序中怎么找到多线程的安全问题：

1、明确哪些代码是多线程运行代码。

2、明确共享数据。

3、明确多线程运行代码中哪些语句是操作共享数据的。

 

同步函数中，如果操作共享数据的代码和别的代码混在一起

那么可以在这个类中将共享数据的代码拿出来封装进一个新的方法，构造同步函数，在原来的方法中只要调用这个方法就行了。

 

同步函数用的是哪个锁？

函数需要被对象调用，那么函数都有一个所属对象引用，就是this

所以同步函数使用的锁是this（可以用卖票的那个小程序进行验证）

 

同步函数被静态修饰后，锁是哪个？

通过验证，发现不是this，因为静态方法中也不可以定义this

静态进内存时，内存中没有本类对象，但一定有该类对应的字节码文件对象。

类名.class  该对象的类型是Class

验证后发现，静态的同步方法，使用的锁是该方法所在类的字节码文件对象。

即：如果这个类是 class Demo{}；那么对象就是Demo.class 

  

线程间通信：

其实就是多个线程在操作同一个资源，但是操作的动作不同。

wait()；notify()；notifyAll()；

都使用在同步中，因为要对持有监视器（即锁）的线程操作。所以要使用在同步中，因为只有同步才具有锁。

 

为什么这些操作线程的方法要定义在object类中呢？

因为这些方法在操作同步中线程时，都必须要标识它们所操作线程中持有的锁，只有同一个锁上的被等待线程，才可以被同一个锁上notify唤醒。不可以对不同锁中的线程进行唤醒。

也就是说，等待和唤醒必须是同一个锁。

而锁可以是任意对象，所以可以被任意对象调用的方法定义在object类中。

 

升级到JDK1.5之后，提供了多线程升级解决方案：

将同步synchronized 替换成显示Lock操作，将object中的wait，notify，notifyAll 替换成了condition 对象。该对象可以通过Lock锁进行获取，还可以实现本方只唤醒自己的操作。

 

停止线程：

Stop方法已经过时。

想要停止，只有run方法结束。

开启多线程运行，运行代码通常是循环结构，只要控制住循环，就可以让run方法结束，也就是线程结束。

特殊情况：interrupt()方法

当线程处于冻结状态，就不会读取到标记，线程就不会结束。

Interrupt:将处于冻结状态的线程，强制恢复到运行状态。即清除线程的冻结状态

 

守护线程：setDaemon(boolean)

该方法必须在启动前调用。

当正在运行的线程都是守护线程时，Java虚拟机退出。

 

Join()方法：

当A线程执行到了B线程的.join()方法时，A就会等待，等B线程都执行完，A才会执行。

join（）方法，可以用于临时加入线程执行

习题：生产者和消费者。每生产出一个产品，卖出这个产品后再生产下一个产品，保证其有序性。分析：定义一个资源类，将生产和消费的方法都定义到这个类中，用线程。

public class Demo8 {public static void main(String[] args){Res r = new Res();//创建资源类的对象Pro p = new Pro(r);//必有得有资源对象才能生产Cus c = new Cus(r);//必有得有资源对象才能卖出Thread t1 = new Thread(p);//两个线程生产Thread t2 = new Thread(p);Thread t3 = new Thread(c);//两个线程消费Thread t4 = new Thread(c);t1.start();//调用这几个线程的run方法t2.start();t3.start();t4.start();}}//资源类class Res {private String name;//产品名private int num = 1;//产品编号private boolean flag;//标记，默认为falsepublic synchronized void pro(String name)//生产方法{// 定义while判断标记,是为了让被唤醒的线程再一次判断标记while (flag){try{wait();}catch(Exception e){}//这里先省略处理方法}//初始化时将编号一起赋给产品this.name = name+".."+num++;//必须把这个放在循环里面，要不就是先消费，后生产了System.out.println(Thread.currentThread().getName()+"...生产"+this.name);//这里必须加this.nameflag = true ;//只用notify，容易出现只唤醒本方线程的情况。导致程序中的所有线程都等待。所以用notifyAll唤醒所有等待线程this.notifyAll();}public synchronized void cus()//消费已经生产出来的商品，所以这里的参数应该为空{while(!flag){try{wait();}catch(Exception e){}}//Thread.currentThread().getName()，线程的名称System.out.println(Thread.currentThread().getName()+"......消费"+this.name);flag = false;this.notifyAll();}}class Pro implements Runnable{private Res r;Pro(Res r){this.r = r;}public void run()//覆盖接口中的方法{while(true)//无限循环的一种形式，为了更加直观的看出效果{r.pro("茶杯");//调用生产的方法，传入产品名称：茶杯}}}class Cus implements Runnable{private Res r;Cus(Res r){this.r = r;}public void run(){while(true){r.cus();}}}

输出结果：

Thread-1...生产茶杯..101329Thread-3......消费茶杯..101329Thread-0...生产茶杯..101330Thread-3......消费茶杯..101330Thread-1...生产茶杯..101331Thread-2......消费茶杯..101331Thread-1...生产茶杯..101332Thread-3......消费茶杯..101332Thread-0...生产茶杯..101333Thread-3......消费茶杯..101333Thread-1...生产茶杯..101334Thread-2......消费茶杯..101334Thread-1...生产茶杯..101335Thread-3......消费茶杯..101335Thread-0...生产茶杯..101336Thread-3......消费茶杯..101336Thread-1...生产茶杯..101337Thread-2......消费茶杯..101337Thread-1...生产茶杯..101338Thread-3......消费茶杯..101338Thread-0...生产茶杯..101339Thread-3......消费茶杯..101339Thread-1...生产茶杯..101340Thread-2......消费茶杯..101340Thread-1...生产茶杯..101341Thread-3......消费茶杯..101341Thread-0...生产茶杯..101342Thread-3......消费茶杯..101342Thread-1...生产茶杯..101343Thread-2......消费茶杯..101343Thread-1...生产茶杯..101344Thread-3......消费茶杯..101344Thread-0...生产茶杯..101345Thread-3......消费茶杯..101345

升级到JDK1.5之后，提供了多线程升级解决方案：

将同步synchronized 替换成显示Lock操作，将object中的wait，notify，notifyAll 替换成了condition 对象。该对象可以通过Lock锁进行获取，还可以实现本方只唤醒自己的操作。

 * Lock:替代了Synchronizedlock unlocknewCondition()Condition：替代了Object wait notify notifyAllawait();signal();signalAll(); */package Thread;import java.util.concurrent.locks.*;//导入包public class Demo9 {public static void main(String[] args){Resource r = new Resource();Produce p = new Produce(r);Customer c = new Customer(r);Thread t1 = new Thread(p);Thread t2 = new Thread(p);Thread t3 = new Thread(c);Thread t4 = new Thread(c);t1.start();//调用线程的run方法t2.start();t3.start();t4.start();}}class Resource{private String name;private int num;private boolean flag;private Lock lock = new ReentrantLock();//Condition condition = lock.newCondition();  //让对应的对象等待，然后在用对应的对象唤醒该对象，所以可以用下面的方法private Condition condition_pro = lock.newCondition();private Condition condition_cus = lock.newCondition();public void pro(String name)throws InterruptedException {lock.lock();//加锁try{ //await()方法在while里面，每次被唤醒都需要判断一次条件flagwhile(flag){condition_pro.await();//在pro方法里面，让pro方法等待}this.name = name + "...."+num++;//让编号随着产品的增加而增加System.out.println(Thread.currentThread().getName()+"...生产.."+this.name);flag = true;condition_cus.signal();//唤醒cus对象 }finally//执行完后释放锁{lock.unlock();//释放锁}}public void cus()throws InterruptedException{lock.lock();try{while(!flag){condition_cus.await();//在cus方法里，让cus方法等待}System.out.println(Thread.currentThread().getName()+".....消费....."+this.name);flag = false;condition_pro.signal();//唤醒pro方法}finally{lock.unlock();}} }class Produce implements Runnable{private Resource res;Produce(Resource res){this.res = res;}public void run(){while(true){try{res.pro("茶杯");}catch(InterruptedException e){}}}}class Customer implements Runnable{private Resource res;Customer(Resource res){this.res = res;}public void run(){while(true){try{res.cus();}catch(InterruptedException e){}}}}

输出结果：

Thread-0...生产..茶杯....58658Thread-3.....消费.....茶杯....58658Thread-1...生产..茶杯....58659Thread-2.....消费.....茶杯....58659Thread-0...生产..茶杯....58660Thread-3.....消费.....茶杯....58660Thread-1...生产..茶杯....58661Thread-2.....消费.....茶杯....58661Thread-0...生产..茶杯....58662Thread-3.....消费.....茶杯....58662Thread-1...生产..茶杯....58663Thread-2.....消费.....茶杯....58663Thread-0...生产..茶杯....58664Thread-3.....消费.....茶杯....58664Thread-1...生产..茶杯....58665Thread-2.....消费.....茶杯....58665Thread-0...生产..茶杯....58666Thread-3.....消费.....茶杯....58666Thread-1...生产..茶杯....58667Thread-2.....消费.....茶杯....58667Thread-0...生产..茶杯....58668Thread-3.....消费.....茶杯....58668Thread-1...生产..茶杯....58669Thread-2.....消费.....茶杯....58669Thread-0...生产..茶杯....58670Thread-3.....消费.....茶杯....58670Thread-1...生产..茶杯....58671Thread-2.....消费.....茶杯....58671Thread-0...生产..茶杯....58672Thread-3.....消费.....茶杯....58672

多线程

 

进程：是一个正在执行中的程序。每一个进程执行都有一个执行顺序。该顺序是一个执行路径，或者叫一个控制单元。

线程：就是进程中的一个独立的控制单元。线程在控制着进程的执行。

一个进程中，至少有一个线程。

主线程：Java虚拟机启动的时候就会有一个进程java.exe。该进程中至少一个线程负责java程序的执行。而且这个线程运行的代码存在于main方法中。该线程称之为主线程。

扩展：

其实更细节说明虚拟机（jvm），jvm启动不止一个线程，还有负责垃圾回收的线程

 

如何在自定义的代码中，自定义一个线程呢？

通过对API的查找，java已经提供了对线程这类事物的描述。就是Thread类。

创建线程的第一种方式：继承Thread类。（通过查API表查到的）

步骤：

1、定义类继承Thread。

2、复写Thread类中的run方法。

目的：将自定义的代码存储在run方法中，让线程运行。

不覆写的话，运行的就是Thread类中的run方法。

3、调用线程的start方法。

该方法有两个作用：启动线程，调用run方法。

注意：其实，创建对象就是创建一个线程；调用这个对象的方法才是真正的启动这个线程。

Thread类用于描述线程。该类就定义一个功能，用于存储线程要运行的代码。该功能就是run方法。也就是说Thread类中的run方法，用于存储线程要运行的代码。

注意：运行结果每一次都不同。

因为多个线程都在获取CPU的执行使用权。CPU执行到哪个程序，该程序就运行。

明确一点，在某一时刻，只能有一个程序在运行。（多核除外）

其实是CPU在做着快速的切换，以达到看上去是同时运行的效果。

我们可以形象的把多线程的运行认为是在互相抢夺CPU的执行使用权。

这就是多线程的一个特性：随机性。

哪个程序先抢到就先执行，至于执行多长，CPU说了算。

创建线程的第二种方式：实现Runnable接口

步骤：

1、定义类实现Runnable 接口

2、覆盖Runnable 接口中的run方法

将线程要运行的代码存放在该run方法中。

3、通过Thread类建立线程对象

4、将Runnable接口的子类对象作为实际参数传递给Thread类的构造函数

为什么要将Runnable接口的子类对象传递给Thread类的构造函数？

因为，自定义的run方法所属的对象是Runnable接口的子类对象。所以要让线程去指定 指定对象 的run方法，就必须明确该run方法所属对象。

5、调用Thread类的start方法开启线程并调用Runnable接口子类的run方法

 

实现方式和继承方式的区别：

继承Thread：  线程代码存放在Thread子类的run方法中。

实现Runnable：线程代码存放在接口的子类的run方法中。

实现方式好处：避免了单继承的局限性。在定义线程时，建议使用实现的方式

 

多线程的安全问题：

问题原因：

当多条语句在操作同一个线程共享数据时，一个线程对多条语句只执行了一部分，还没执行完，另一个线程参与进来执行，导致共享数据的错误。

解决办法：

对多条操作共享数据的语句，只能让一个线程都执行完，在执行过程中，其他线程不可以参与执行。

JAVA对于多线程的安全问题，提供了专业的解决方式：就是同步代码块。

格式：

synchronized（对象）

{

需要被同步的代码块

}

 

*需要被同步的代码块：看哪些数据在操作共享数据，就属性需要被同步的代码块

对象如同锁。持有锁的线程可以在同步中执行。

没有持有锁的线程即使获取了CPU的执行权，也进不去，因为没有获取锁。

 

同步的前提：

1、必须要有两个或者两个以上的线程。

2、必须是多个线程使用同一个锁。

同步的好处：解决了多线程的安全问题

同步的弊端：多个线程都需要判断锁，较为消耗资源。当然，这个资源是在允许的范围内。

必须保证同步中只有一个线程在运行。把run方法中的代码全部放在同步中，那就使得代码变成了单线程。

 

在程序中怎么找到多线程的安全问题：

1、明确哪些代码是多线程运行代码。

2、明确共享数据。

3、明确多线程运行代码中哪些语句是操作共享数据的。

 

同步函数中，如果操作共享数据的代码和别的代码混在一起

那么可以在这个类中将共享数据的代码拿出来封装进一个新的方法，构造同步函数，在原来的方法中只要调用这个方法就行了。

 

同步函数用的是哪个锁？

函数需要被对象调用，那么函数都有一个所属对象引用，就是this

所以同步函数使用的锁是this（可以用卖票的那个小程序进行验证）

 

同步函数被静态修饰后，锁是哪个？

通过验证，发现不是this，因为静态方法中也不可以定义this

静态进内存时，内存中没有本类对象，但一定有该类对应的字节码文件对象。

类名.class  该对象的类型是Class

验证后发现，静态的同步方法，使用的锁是该方法所在类的字节码文件对象。

即：如果这个类是 class Demo{}；那么对象就是Demo.class 

  

线程间通信：

其实就是多个线程在操作同一个资源，但是操作的动作不同。

wait()；notify()；notifyAll()；

都使用在同步中，因为要对持有监视器（即锁）的线程操作。所以要使用在同步中，因为只有同步才具有锁。

 

为什么这些操作线程的方法要定义在object类中呢？

因为这些方法在操作同步中线程时，都必须要标识它们所操作线程中持有的锁，只有同一个锁上的被等待线程，才可以被同一个锁上notify唤醒。不可以对不同锁中的线程进行唤醒。

也就是说，等待和唤醒必须是同一个锁。

而锁可以是任意对象，所以可以被任意对象调用的方法定义在object类中。

 

升级到JDK1.5之后，提供了多线程升级解决方案：

将同步synchronized 替换成显示Lock操作，将object中的wait，notify，notifyAll 替换成了condition 对象。该对象可以通过Lock锁进行获取，还可以实现本方只唤醒自己的操作。

 

停止线程：

Stop方法已经过时。

想要停止，只有run方法结束。

开启多线程运行，运行代码通常是循环结构，只要控制住循环，就可以让run方法结束，也就是线程结束。

特殊情况：interrupt()方法

当线程处于冻结状态，就不会读取到标记，线程就不会结束。

Interrupt:将处于冻结状态的线程，强制恢复到运行状态。即清除线程的冻结状态

 

守护线程：setDaemon(boolean)

该方法必须在启动前调用。

当正在运行的线程都是守护线程时，Java虚拟机退出。

 

Join()方法：

当A线程执行到了B线程的.join()方法时，A就会等待，等B线程都执行完，A才会执行。

join（）方法，可以用于临时加入线程执行

习题：生产者和消费者。每生产出一个产品，卖出这个产品后再生产下一个产品，保证其有序性。分析：定义一个资源类，将生产和消费的方法都定义到这个类中，用线程。

public class Demo8 {public static void main(String[] args){Res r = new Res();//创建资源类的对象Pro p = new Pro(r);//必有得有资源对象才能生产Cus c = new Cus(r);//必有得有资源对象才能卖出Thread t1 = new Thread(p);//两个线程生产Thread t2 = new Thread(p);Thread t3 = new Thread(c);//两个线程消费Thread t4 = new Thread(c);t1.start();//调用这几个线程的run方法t2.start();t3.start();t4.start();}}//资源类class Res {private String name;//产品名private int num = 1;//产品编号private boolean flag;//标记，默认为falsepublic synchronized void pro(String name)//生产方法{// 定义while判断标记,是为了让被唤醒的线程再一次判断标记while (flag){try{wait();}catch(Exception e){}//这里先省略处理方法}//初始化时将编号一起赋给产品this.name = name+".."+num++;//必须把这个放在循环里面，要不就是先消费，后生产了System.out.println(Thread.currentThread().getName()+"...生产"+this.name);//这里必须加this.nameflag = true ;//只用notify，容易出现只唤醒本方线程的情况。导致程序中的所有线程都等待。所以用notifyAll唤醒所有等待线程this.notifyAll();}public synchronized void cus()//消费已经生产出来的商品，所以这里的参数应该为空{while(!flag){try{wait();}catch(Exception e){}}//Thread.currentThread().getName()，线程的名称System.out.println(Thread.currentThread().getName()+"......消费"+this.name);flag = false;this.notifyAll();}}class Pro implements Runnable{private Res r;Pro(Res r){this.r = r;}public void run()//覆盖接口中的方法{while(true)//无限循环的一种形式，为了更加直观的看出效果{r.pro("茶杯");//调用生产的方法，传入产品名称：茶杯}}}class Cus implements Runnable{private Res r;Cus(Res r){this.r = r;}public void run(){while(true){r.cus();}}}

输出结果：

Thread-1...生产茶杯..101329Thread-3......消费茶杯..101329Thread-0...生产茶杯..101330Thread-3......消费茶杯..101330Thread-1...生产茶杯..101331Thread-2......消费茶杯..101331Thread-1...生产茶杯..101332Thread-3......消费茶杯..101332Thread-0...生产茶杯..101333Thread-3......消费茶杯..101333Thread-1...生产茶杯..101334Thread-2......消费茶杯..101334Thread-1...生产茶杯..101335Thread-3......消费茶杯..101335Thread-0...生产茶杯..101336Thread-3......消费茶杯..101336Thread-1...生产茶杯..101337Thread-2......消费茶杯..101337Thread-1...生产茶杯..101338Thread-3......消费茶杯..101338Thread-0...生产茶杯..101339Thread-3......消费茶杯..101339Thread-1...生产茶杯..101340Thread-2......消费茶杯..101340Thread-1...生产茶杯..101341Thread-3......消费茶杯..101341Thread-0...生产茶杯..101342Thread-3......消费茶杯..101342Thread-1...生产茶杯..101343Thread-2......消费茶杯..101343Thread-1...生产茶杯..101344Thread-3......消费茶杯..101344Thread-0...生产茶杯..101345Thread-3......消费茶杯..101345

升级到JDK1.5之后，提供了多线程升级解决方案：

将同步synchronized 替换成显示Lock操作，将object中的wait，notify，notifyAll 替换成了condition 对象。该对象可以通过Lock锁进行获取，还可以实现本方只唤醒自己的操作。

 * Lock:替代了Synchronizedlock unlocknewCondition()Condition：替代了Object wait notify notifyAllawait();signal();signalAll(); */package Thread;import java.util.concurrent.locks.*;//导入包public class Demo9 {public static void main(String[] args){Resource r = new Resource();Produce p = new Produce(r);Customer c = new Customer(r);Thread t1 = new Thread(p);Thread t2 = new Thread(p);Thread t3 = new Thread(c);Thread t4 = new Thread(c);t1.start();//调用线程的run方法t2.start();t3.start();t4.start();}}class Resource{private String name;private int num;private boolean flag;private Lock lock = new ReentrantLock();//Condition condition = lock.newCondition();  //让对应的对象等待，然后在用对应的对象唤醒该对象，所以可以用下面的方法private Condition condition_pro = lock.newCondition();private Condition condition_cus = lock.newCondition();public void pro(String name)throws InterruptedException {lock.lock();//加锁try{ //await()方法在while里面，每次被唤醒都需要判断一次条件flagwhile(flag){condition_pro.await();//在pro方法里面，让pro方法等待}this.name = name + "...."+num++;//让编号随着产品的增加而增加System.out.println(Thread.currentThread().getName()+"...生产.."+this.name);flag = true;condition_cus.signal();//唤醒cus对象 }finally//执行完后释放锁{lock.unlock();//释放锁}}public void cus()throws InterruptedException{lock.lock();try{while(!flag){condition_cus.await();//在cus方法里，让cus方法等待}System.out.println(Thread.currentThread().getName()+".....消费....."+this.name);flag = false;condition_pro.signal();//唤醒pro方法}finally{lock.unlock();}} }class Produce implements Runnable{private Resource res;Produce(Resource res){this.res = res;}public void run(){while(true){try{res.pro("茶杯");}catch(InterruptedException e){}}}}class Customer implements Runnable{private Resource res;Customer(Resource res){this.res = res;}public void run(){while(true){try{res.cus();}catch(InterruptedException e){}}}}

输出结果：

Thread-0...生产..茶杯....58658Thread-3.....消费.....茶杯....58658Thread-1...生产..茶杯....58659Thread-2.....消费.....茶杯....58659Thread-0...生产..茶杯....58660Thread-3.....消费.....茶杯....58660Thread-1...生产..茶杯....58661Thread-2.....消费.....茶杯....58661Thread-0...生产..茶杯....58662Thread-3.....消费.....茶杯....58662Thread-1...生产..茶杯....58663Thread-2.....消费.....茶杯....58663Thread-0...生产..茶杯....58664Thread-3.....消费.....茶杯....58664Thread-1...生产..茶杯....58665Thread-2.....消费.....茶杯....58665Thread-0...生产..茶杯....58666Thread-3.....消费.....茶杯....58666Thread-1...生产..茶杯....58667Thread-2.....消费.....茶杯....58667Thread-0...生产..茶杯....58668Thread-3.....消费.....茶杯....58668Thread-1...生产..茶杯....58669Thread-2.....消费.....茶杯....58669Thread-0...生产..茶杯....58670Thread-3.....消费.....茶杯....58670Thread-1...生产..茶杯....58671Thread-2.....消费.....茶杯....58671Thread-0...生产..茶杯....58672Thread-3.....消费.....茶杯....58672