浅谈java多线程

910阅读　2评论2013-05-17　sq1990
分类：Java

                                                                      java中的多线程


 在java中要想实现多线程，有两种手段，一种是继续Thread类，另外一种是实现Runable接口。

对于直接继承Thread的类来说

点击(此处)折叠或打开

  1. /**
  2.  * @author Rollen-Holt 继承Thread类,直接调用run方法
  3.  * */
  4. class hello extends Thread {
  5.  
  6.     public hello() {
  7.  
  8.     }
  9.  
  10.     public hello(String name) {
  11.         this.name = name;
  12.     }
  13.  
  14.     public void run() {
  15.         for (int i = 0; i < 5; i++) {
  16.             System.out.println(name + "运行 " + i);
  17.         }
  18.     }
  19.  
  20.     public static void main(String[] args) {
  21.         hello h1=new hello("A");
  22.         hello h2=new hello("B");
  23.         h1.run();
  24.         h2.run();
  25.     }
  26.  
  27.     private String name;
  28. }

【运行结果】：

A运行     0

A运行     1

A运行     2

A运行     3

A运行     4

B运行     0

B运行     1

B运行     2

B运行     3

B运行     4

我们会发现这些都是顺序执行的，说明我们的调用方法不对，应该调用的是start（）方法。

当我们把上面的主函数修改为如下所示的时候：


点击(此处)折叠或打开

  1. public static void main(String[] args) {
  2.         hello h1=new hello("A");
  3.         hello h2=new hello("B");
  4.         h1.start();
  5.         h2.start();
  6.     }

然后运行程序，输出的可能的结果如下：

A运行     0

B运行     0

B运行     1

B运行     2

B运行     3

B运行     4

A运行     1

A运行     2

A运行     3

A运行     4

因为需要用到CPU的资源，所以每次的运行结果基本是都不一样的，呵呵。

注意：虽然我们在这里调用的是start（）方法，但是实际上调用的还是run（）方法的主体。

通过实现Runnable接口：
来先看一个小例子吧：

点击(此处)折叠或打开

  1. /**
  2.  * @author Rollen-Holt 实现Runnable接口
  3.  * */
  4. class hello implements Runnable {
  5.  
  6.     public hello() {
  7.  
  8.     }
  9.  
  10.     public hello(String name) {
  11.         this.name = name;
  12.     }
  13.  
  14.     public void run() {
  15.         for (int i = 0; i < 5; i++) {
  16.             System.out.println(name + "运行 " + i);
  17.         }
  18.     }
  19.  
  20.     public static void main(String[] args) {
  21.         hello h1=new hello("线程A");
  22.         Thread demo= new Thread(h1);
  23.         hello h2=new hello("线程Ｂ");
  24.         Thread demo1=new Thread(h2);
  25.         demo.start();
  26.         demo1.start();
  27.     }
  28.  
  29.     private String name;
  30. }

【可能的运行结果】：

线程A运行     0

线程Ｂ运行     0

线程Ｂ运行     1

线程Ｂ运行     2

线程Ｂ运行     3

线程Ｂ运行     4

线程A运行     1

线程A运行     2

线程A运行     3

线程A运行     4

Thread和Runnable的区别：

如果一个类继承Thread，则不适合资源共享。但是如果实现了Runable接口的话，则很容易的实现资源共享。



点击(此处)折叠或打开

  1. /**
  2.  * @author Rollen-Holt 继承Thread类，不能资源共享
  3.  * */
  4. class hello extends Thread {
  5.     public void run() {
  6.         for (int i = 0; i < 7; i++) {
  7.             if (count > 0) {
  8.                 System.out.println("count= " + count--);
  9.             }
  10.         }
  11.     }
  12.  
  13.     public static void main(String[] args) {
  14.         hello h1 = new hello();
  15.         hello h2 = new hello();
  16.         hello h3 = new hello();
  17.         h1.start();
  18.         h2.start();
  19.         h3.start();
  20.     }
  21.  
  22.     private int count = 5;
  23. }

【运行结果】：

count= 5

count= 4

count= 3

count= 2

count= 1

count= 5

count= 4

count= 3

count= 2

count= 1

count= 5

count= 4

count= 3

count= 2

count= 1

大家可以想象，如果这个是一个买票系统的话，如果count表示的是车票的数量的话，说明并没有实现资源的共享。

我们换为Runnable接口


点击(此处)折叠或打开

  1. class MyThread implements Runnable{
  2.  
  3.     private int ticket = 5; //5张票
  4.  
  5.     public void run() {
  6.         for (int i=0; i<=20; i++) {
  7.             if (this.ticket > 0) {
  8.                 System.out.println(Thread.currentThread().getName()+ "正在卖票"+this.ticket--);
  9.             }
  10.         }
  11.     }
  12. }
  13. public class lzwCode {
  14.      
  15.     public static void main(String [] args) {
  16.         MyThread my = new MyThread();
  17.         new Thread(my, "1号窗口").start();
  18.         new Thread(my, "2号窗口").start();
  19.         new Thread(my, "3号窗口").start();
  20.     }
  21. }

【运行结果】：

count= 5

count= 4

count= 3

count= 2

count= 1


总结一下吧：

实现Runnable接口比继承Thread类所具有的优势：

1）：适合多个相同的程序代码的线程去处理同一个资源

2）：可以避免java中的单继承的限制

3）：增加程序的健壮性，代码可以被多个线程共享，代码和数据独立。

所以，本人建议大家劲量实现接口。

点击(此处)折叠或打开

  1. /**
  2.  * @author Rollen-Holt
  3.  * 取得线程的名称
  4.  * */
  5. class hello implements Runnable {
  6.     public void run() {
  7.         for (int i = 0; i < 3; i++) {
  8.             System.out.println(Thread.currentThread().getName());
  9.         }
  10.     }
  11.  
  12.     public static void main(String[] args) {
  13.         hello he = new hello();
  14.         new Thread(he,"A").start();
  15.         new Thread(he,"B").start();
  16.         new Thread(he).start();
  17.     }
  18. }

【运行结果】：

A

A

A

B

B

B

Thread-0

Thread-0

Thread-0

说明如果我们没有指定名字的话，系统自动提供名字。

提醒一下大家：main方法其实也是一个线程。在java中所以的线程都是同时启动的，至于什么时候，哪个先执行，完全看谁先得到CPU的资源。

 

在java中，每次程序运行至少启动2个线程。一个是main线程，一个是垃圾收集线程。因为每当使用java命令执行一个类的时候，实际上都会启动一个ＪＶＭ，每一个ｊＶＭ实习在就是在操作系统中启动了一个进程。

判断线程是否启动

点击(此处)折叠或打开

  1. /**
  2.  * @author Rollen-Holt 判断线程是否启动
  3.  * */
  4. class hello implements Runnable {
  5.     public void run() {
  6.         for (int i = 0; i < 3; i++) {
  7.             System.out.println(Thread.currentThread().getName());
  8.         }
  9.     }
  10.  
  11.     public static void main(String[] args) {
  12.         hello he = new hello();
  13.         Thread demo = new Thread(he);
  14.         System.out.println("线程启动之前---》" + demo.isAlive());
  15.         demo.start();
  16.         System.out.println("线程启动之后---》" + demo.isAlive());
  17.     }
  18. }

【运行结果】

线程启动之前---》false

线程启动之后---》true

Thread-0

Thread-0

Thread-0

主线程也有可能在子线程结束之前结束。并且子线程不受影响，不会因为主线程的结束而结束。

 

线程的强制执行：


点击(此处)折叠或打开

  1. /**
  2.      * @author Rollen-Holt 线程的强制执行
  3.      * */
  4.     class hello implements Runnable {
  5.         public void run() {
  6.             for (int i = 0; i < 3; i++) {
  7.                 System.out.println(Thread.currentThread().getName());
  8.             }
  9.         }
  10.      
  11.         public static void main(String[] args) {
  12.             hello he = new hello();
  13.             Thread demo = new Thread(he,"线程");
  14.             demo.start();
  15.             for(int i=0;i<50;++i){
  16.                 if(i>10){
  17.                     try{
  18.                         demo.join(); //强制执行demo
  19.                     }catch (Exception e) {
  20.                         e.printStackTrace();
  21.                     }
  22.                 }
  23.                 System.out.println("main 线程执行-->"+i);
  24.             }
  25.         }
  26.     }

【运行的结果】：

main 线程执行-->0

main 线程执行-->1

main 线程执行-->2

main 线程执行-->3

main 线程执行-->4

main 线程执行-->5

main 线程执行-->6

main 线程执行-->7

main 线程执行-->8

main 线程执行-->9

main 线程执行-->10

线程

线程

线程

main 线程执行-->11

main 线程执行-->12

main 线程执行-->13

线程的休眠：

点击(此处)折叠或打开

  1. /**
  2.  * @author Rollen-Holt 线程的休眠
  3.  * */
  4. class hello implements Runnable {
  5.     public void run() {
  6.         for (int i = 0; i < 3; i++) {
  7.             try {
  8.                 Thread.sleep(2000);
  9.             } catch (Exception e) {
  10.                 e.printStackTrace();
  11.             }
  12.             System.out.println(Thread.currentThread().getName() + i);
  13.         }
  14.     }
  15.  
  16.     public static void main(String[] args) {
  17.         hello he = new hello();
  18.         Thread demo = new Thread(he, "线程");
  19.         demo.start();
  20.     }
  21. }

【运行结果】：（结果每隔2s输出一个）

线程0

线程1

线程2

线程的中断：

点击(此处)折叠或打开

  1. /**
  2.  * @author Rollen-Holt 线程的中断
  3.  * */
  4. class hello implements Runnable {
  5.     public void run() {
  6.         System.out.println("执行run方法");
  7.         try {
  8.             Thread.sleep(10000);
  9.             System.out.println("线程完成休眠");
  10.         } catch (Exception e) {
  11.             System.out.println("休眠被打断");
  12.             return; //返回到程序的调用处
  13.         }
  14.         System.out.println("线程正常终止");
  15.     }
  16.  
  17.     public static void main(String[] args) {
  18.         hello he = new hello();
  19.         Thread demo = new Thread(he, "线程");
  20.         demo.start();
  21.         try{
  22.             Thread.sleep(2000);
  23.         }catch (Exception e) {
  24.             e.printStackTrace();
  25.         }
  26.         demo.interrupt(); //2s后中断线程
  27.     }
  28. }

【运行结果】：

执行run方法

休眠被打断

 

在java程序中，只要前台有一个线程在运行，整个java程序进程不会小时，所以此时可以设置一个后台线程，这样即使java进程小时了，此后台线程依然能够继续运行。


点击(此处)折叠或打开

  1. /**
  2.  * @author Rollen-Holt 后台线程
  3.  * */
  4. class hello implements Runnable {
  5.     public void run() {
  6.         while (true) {
  7.             System.out.println(Thread.currentThread().getName() + "在运行");
  8.         }
  9.     }
  10.  
  11.     public static void main(String[] args) {
  12.         hello he = new hello();
  13.         Thread demo = new Thread(he, "线程");
  14.         demo.setDaemon(true);
  15.         demo.start();
  16.     }
  17. }

虽然有一个死循环，但是程序还是可以执行完的。因为在死循环中的线程操作已经设置为后台运行了。

线程的优先级：

/**
 * @author Rollen-Holt 线程的优先级
 * */
class hello implements Runnable {
    public void run() {
        for(int i=0;i<5;++i){
            System.out.println(Thread.currentThread().getName()+"运行"+i);
        }
    }
 
    public static void main(String[] args) {
        Thread h1=new Thread(new hello(),"A");
        Thread h2=new Thread(new hello(),"B");
        Thread h3=new Thread(new hello(),"C");
        h1.setPriority(8);
        h2.setPriority(2);
        h3.setPriority(6);
        h1.start();
        h2.start();
        h3.start();
         
    }
}

【运行结果】：

A运行0

A运行1

A运行2

A运行3

A运行4

B运行0

C运行0

C运行1

C运行2

C运行3

C运行4

B运行1

B运行2

B运行3

B运行4

。但是请读者不要误以为优先级越高就先执行。谁先执行还是取决于谁先去的CPU的资源、

 

另外，主线程的优先级是5.

线程的礼让。

在线程操作中，也可以使用yield（）方法，将一个线程的操作暂时交给其他线程执行。


点击(此处)折叠或打开

  1. /**
  2.  * @author Rollen-Holt 线程的优先级
  3.  * */
  4. class hello implements Runnable {
  5.     public void run() {
  6.         for(int i=0;i<5;++i){
  7.             System.out.println(Thread.currentThread().getName()+"运行"+i);
  8.             if(i==3){
  9.                 System.out.println("线程的礼让");
  10.                 Thread.currentThread().yield();
  11.             }
  12.         }
  13.     }
  14.  
  15.     public static void main(String[] args) {
  16.         Thread h1=new Thread(new hello(),"A");
  17.         Thread h2=new Thread(new hello(),"B");
  18.         h1.start();
  19.         h2.start();
  20.          
  21.     }

A运行0

A运行1

A运行2

A运行3

线程的礼让

A运行4

B运行0

B运行1

B运行2

B运行3

线程的礼让

B运行4


同步和死锁：

【问题引出】:比如说对于买票系统，有下面的代码：


点击(此处)折叠或打开

  1. /**
  2.  * @author Rollen-Holt
  3.  * */
  4. class hello implements Runnable {
  5.     public void run() {
  6.         for(int i=0;i<10;++i){
  7.             if(count>0){
  8.                 try{
  9.                     Thread.sleep(1000);
  10.                 }catch(InterruptedException e){
  11.                     e.printStackTrace();
  12.                 }
  13.                 System.out.println(count--);
  14.             }
  15.         }
  16.     }
  17.  
  18.     public static void main(String[] args) {
  19.         hello he=new hello();
  20.         Thread h1=new Thread(he);
  21.         Thread h2=new Thread(he);
  22.         Thread h3=new Thread(he);
  23.         h1.start();
  24.         h2.start();
  25.         h3.start();
  26.     }
  27.     private int count=5;
  28. }

【运行结果】：

5

4

3

2

1

0

-1

这里出现了-1，显然这个是错的。，应该票数不能为负值。

如果想解决这种问题，就需要使用同步。所谓同步就是在统一时间段中只有有一个线程运行，

其他的线程必须等到这个线程结束之后才能继续执行。

【使用线程同步解决问题】

采用同步的话，可以使用同步代码块和同步方法两种来完成。

 

【同步代码块】：

语法格式：

synchronized（同步对象）{

 //需要同步的代码

}

但是一般都把当前对象this作为同步对象。

比如对于上面的买票的问题，如下：


点击(此处)折叠或打开

  1. /**
  2.  * @author Rollen-Holt
  3.  * */
  4. class hello implements Runnable {
  5.     public void run() {
  6.         for(int i=0;i<10;++i){
  7.             synchronized (this) {
  8.                 if(count>0){
  9.                     try{
  10.                         Thread.sleep(1000);
  11.                     }catch(InterruptedException e){
  12.                         e.printStackTrace();
  13.                     }
  14.                     System.out.println(count--);
  15.                 }
  16.             }
  17.         }
  18.     }
  19.  
  20.     public static void main(String[] args) {
  21.         hello he=new hello();
  22.         Thread h1=new Thread(he);
  23.         Thread h2=new Thread(he);
  24.         Thread h3=new Thread(he);
  25.         h1.start();
  26.         h2.start();
  27.         h3.start();
  28.     }
  29.     private int count=5;
  30. }


点击(此处)折叠或打开

  1. /**
  2.  * @author Rollen-Holt
  3.  * */
  4. class hello implements Runnable {
  5.     public void run() {
  6.         for(int i=0;i<10;++i){
  7.             synchronized (this) {
  8.                 if(count>0){
  9.                     try{
  10.                         Thread.sleep(1000);
  11.                     }catch(InterruptedException e){
  12.                         e.printStackTrace();
  13.                     }
  14.                     System.out.println(count--);
  15.                 }
  16.             }
  17.         }
  18.     }
  19.  
  20.     public static void main(String[] args) {
  21.         hello he=new hello();
  22.         Thread h1=new Thread(he);
  23.         Thread h2=new Thread(he);
  24.         Thread h3=new Thread(he);
  25.         h1.start();
  26.         h2.start();
  27.         h3.start();
  28.     }
  29.     private int count=5;
  30. }

【运行结果】：（每一秒输出一个结果）

5

4

3

2

1

【同步方法】

也可以采用同步方法。

语法格式为synchronized 方法返回类型方法名（参数列表）{

    // 其他代码

}

现在，我们采用同步方法解决上面的问题。



点击(此处)折叠或打开

  1. /**
  2.  * @author Rollen-Holt
  3.  * */
  4. class hello implements Runnable {
  5.     public void run() {
  6.         for (int i = 0; i < 10; ++i) {
  7.             sale();
  8.         }
  9.     }
  10.  
  11.     public synchronized void sale() {
  12.         if (count > 0) {
  13.             try {
  14.                 Thread.sleep(1000);
  15.             } catch (InterruptedException e) {
  16.                 e.printStackTrace();
  17.             }
  18.             System.out.println(count--);
  19.         }
  20.     }
  21.  
  22.     public static void main(String[] args) {
  23.         hello he = new hello();
  24.         Thread h1 = new Thread(he);
  25.         Thread h2 = new Thread(he);
  26.         Thread h3 = new Thread(he);
  27.         h1.start();
  28.         h2.start();
  29.         h3.start();
  30.     }
  31.  
  32.     private int count = 5;
  33. }

【运行结果】（每秒输出一个）

5

4

3

2

1

提醒一下，当多个线程共享一个资源的时候需要进行同步，但是过多的同步可能导致死锁。

此处列举经典的生产者和消费者问题。

【生产者和消费者问题】

先看一段有问题的代码。


点击(此处)折叠或打开

  1. class Info {
  2.  
  3.     public String getName() {
  4.         return name;
  5.     }
  6.  
  7.     public void setName(String name) {
  8.         this.name = name;
  9.     }
  10.  
  11.     public int getAge() {
  12.         return age;
  13.     }
  14.  
  15.     public void setAge(int age) {
  16.         this.age = age;
  17.     }
  18.  
  19.     private String name = "Rollen";
  20.     private int age = 20;
  21. }
  22.  
  23. /**
  24.  * 生产者
  25.  * */
  26. class Producer implements Runnable{
  27.     private Info info=null;
  28.     Producer(Info info){
  29.         this.info=info;
  30.     }
  31.      
  32.     public void run(){
  33.         boolean flag=false;
  34.         for(int i=0;i<25;++i){
  35.             if(flag){
  36.                 this.info.setName("Rollen");
  37.                 try{
  38.                     Thread.sleep(100);
  39.                 }catch (Exception e) {
  40.                     e.printStackTrace();
  41.                 }
  42.                 this.info.setAge(20);
  43.                 flag=false;
  44.             }else{
  45.                 this.info.setName("chunGe");
  46.                 try{
  47.                     Thread.sleep(100);
  48.                 }catch (Exception e) {
  49.                     e.printStackTrace();
  50.                 }
  51.                 this.info.setAge(100);
  52.                 flag=true;
  53.             }
  54.         }
  55.     }
  56. }
  57. /**
  58.  * 消费者类
  59.  * */
  60. class Consumer implements Runnable{
  61.     private Info info=null;
  62.     public Consumer(Info info){
  63.         this.info=info;
  64.     }
  65.      
  66.     public void run(){
  67.         for(int i=0;i<25;++i){
  68.             try{
  69.                 Thread.sleep(100);
  70.             }catch (Exception e) {
  71.                 e.printStackTrace();
  72.             }
  73.             System.out.println(this.info.getName()+"<---->"+this.info.getAge());
  74.         }
  75.     }
  76. }
  77.  
  78. /**
  79.  * 测试类
  80.  * */
  81. class hello{
  82.     public static void main(String[] args) {
  83.         Info info=new Info();
  84.         Producer pro=new Producer(info);
  85.         Consumer con=new Consumer(info);
  86.         new Thread(pro).start();
  87.         new Thread(con).start();
  88.     }
  89. }

【运行结果】：

Rollen<---->100

chunGe<---->20

chunGe<---->100

Rollen<---->100

chunGe<---->20

Rollen<---->100

Rollen<---->100

Rollen<---->100

chunGe<---->20

chunGe<---->20

chunGe<---->20

Rollen<---->100

chunGe<---->20

Rollen<---->100

chunGe<---->20

Rollen<---->100

chunGe<---->20

Rollen<---->100

chunGe<---->20

Rollen<---->100

chunGe<---->20

Rollen<---->100

chunGe<---->20

Rollen<---->100

chunGe<---->20

大家可以从结果中看到，名字和年龄并没有对于。

 

那么如何解决呢？

1）加入同步

2）加入等待和唤醒

先来看看加入同步会是如何。


点击(此处)折叠或打开

  1. class Info {
  2.      
  3.     public String getName() {
  4.         return name;
  5.     }
  6.  
  7.     public void setName(String name) {
  8.         this.name = name;
  9.     }
  10.  
  11.     public int getAge() {
  12.         return age;
  13.     }
  14.  
  15.     public void setAge(int age) {
  16.         this.age = age;
  17.     }
  18.  
  19.     public synchronized void set(String name, int age){
  20.         this.name=name;
  21.         try{
  22.             Thread.sleep(100);
  23.         }catch (Exception e) {
  24.             e.printStackTrace();
  25.         }
  26.         this.age=age;
  27.     }
  28.      
  29.     public synchronized void get(){
  30.         try{
  31.             Thread.sleep(100);
  32.         }catch (Exception e) {
  33.             e.printStackTrace();
  34.         }
  35.         System.out.println(this.getName()+"<===>"+this.getAge());
  36.     }
  37.     private String name = "Rollen";
  38.     private int age = 20;
  39. }
  40.  
  41. /**
  42.  * 生产者
  43.  * */
  44. class Producer implements Runnable {
  45.     private Info info = null;
  46.  
  47.     Producer(Info info) {
  48.         this.info = info;
  49.     }
  50.  
  51.     public void run() {
  52.         boolean flag = false;
  53.         for (int i = 0; i < 25; ++i) {
  54.             if (flag) {
  55.                  
  56.                 this.info.set("Rollen", 20);
  57.                 flag = false;
  58.             } else {
  59.                 this.info.set("ChunGe", 100);
  60.                 flag = true;
  61.             }
  62.         }
  63.     }
  64. }
  65.  
  66. /**
  67.  * 消费者类
  68.  * */
  69. class Consumer implements Runnable {
  70.     private Info info = null;
  71.  
  72.     public Consumer(Info info) {
  73.         this.info = info;
  74.     }
  75.  
  76.     public void run() {
  77.         for (int i = 0; i < 25; ++i) {
  78.             try {
  79.                 Thread.sleep(100);
  80.             } catch (Exception e) {
  81.                 e.printStackTrace();
  82.             }
  83.             this.info.get();
  84.         }
  85.     }
  86. }
  87.  
  88. /**
  89.  * 测试类
  90.  * */
  91. class hello {
  92.     public static void main(String[] args) {
  93.         Info info = new Info();
  94.         Producer pro = new Producer(info);
  95.         Consumer con = new Consumer(info);
  96.         new Thread(pro).start();
  97.         new Thread(con).start();
  98.     }
  99. }

【运行结果】：

Rollen<===>20

ChunGe<===>100

ChunGe<===>100

ChunGe<===>100

ChunGe<===>100

ChunGe<===>100

Rollen<===>20

ChunGe<===>100

ChunGe<===>100

ChunGe<===>100

ChunGe<===>100

ChunGe<===>100

ChunGe<===>100

ChunGe<===>100

ChunGe<===>100

ChunGe<===>100

ChunGe<===>100

ChunGe<===>100

ChunGe<===>100

ChunGe<===>100

ChunGe<===>100

ChunGe<===>100

ChunGe<===>100

ChunGe<===>100

ChunGe<===>100

从运行结果来看，错乱的问题解决了，现在是Rollen 对应20，ChunGe对于100

，但是还是出现了重复读取的问题，也肯定有重复覆盖的问题。如果想解决这个问题，就需要使用Object类帮忙了、

，我们可以使用其中的等待和唤醒操作。

要完成上面的功能，我们只需要修改Info类饥渴，在其中加上标志位，并且通过判断标志位完成等待和唤醒的操作，代码如下：


点击(此处)折叠或打开

  1. class Info {
  2.      
  3.     public String getName() {
  4.         return name;
  5.     }
  6.  
  7.     public void setName(String name) {
  8.         this.name = name;
  9.     }
  10.  
  11.     public int getAge() {
  12.         return age;
  13.     }
  14.  
  15.     public void setAge(int age) {
  16.         this.age = age;
  17.     }
  18.  
  19.     public synchronized void set(String name, int age){
  20.         if(!flag){
  21.             try{
  22.                 super.wait();
  23.             }catch (Exception e) {
  24.                 e.printStackTrace();
  25.             }
  26.         }
  27.         this.name=name;
  28.         try{
  29.             Thread.sleep(100);
  30.         }catch (Exception e) {
  31.             e.printStackTrace();
  32.         }
  33.         this.age=age;
  34.         flag=false;
  35.         super.notify();
  36.     }
  37.      
  38.     public synchronized void get(){
  39.         if(flag){
  40.             try{
  41.                 super.wait();
  42.             }catch (Exception e) {
  43.                 e.printStackTrace();
  44.             }
  45.         }
  46.          
  47.         try{
  48.             Thread.sleep(100);
  49.         }catch (Exception e) {
  50.             e.printStackTrace();
  51.         }
  52.         System.out.println(this.getName()+"<===>"+this.getAge());
  53.         flag=true;
  54.         super.notify();
  55.     }
  56.     private String name = "Rollen";
  57.     private int age = 20;
  58.     private boolean flag=false;
  59. }
  60.  
  61. /**
  62.  * 生产者
  63.  * */
  64. class Producer implements Runnable {
  65.     private Info info = null;
  66.  
  67.     Producer(Info info) {
  68.         this.info = info;
  69.     }
  70.  
  71.     public void run() {
  72.         boolean flag = false;
  73.         for (int i = 0; i < 25; ++i) {
  74.             if (flag) {
  75.                  
  76.                 this.info.set("Rollen", 20);
  77.                 flag = false;
  78.             } else {
  79.                 this.info.set("ChunGe", 100);
  80.                 flag = true;
  81.             }
  82.         }
  83.     }
  84. }
  85.  
  86. /**
  87.  * 消费者类
  88.  * */
  89. class Consumer implements Runnable {
  90.     private Info info = null;
  91.  
  92.     public Consumer(Info info) {
  93.         this.info = info;
  94.     }
  95.  
  96.     public void run() {
  97.         for (int i = 0; i < 25; ++i) {
  98.             try {
  99.                 Thread.sleep(100);
  100.             } catch (Exception e) {
  101.                 e.printStackTrace();
  102.             }
  103.             this.info.get();
  104.         }
  105.     }
  106. }
  107.  
  108. /**
  109.  * 测试类
  110.  * */
  111. class hello {
  112.     public static void main(String[] args) {
  113.         Info info = new Info();
  114.         Producer pro = new Producer(info);
  115.         Consumer con = new Consumer(info);
  116.         new Thread(pro).start();
  117.         new Thread(con).start();
  118.     }
  119. }
【程序运行结果】：
Rollen<===>20
ChunGe<===>100
Rollen<===>20
ChunGe<===>100
Rollen<===>20
ChunGe<===>100
Rollen<===>20
ChunGe<===>100
Rollen<===>20
ChunGe<===>100
Rollen<===>20
ChunGe<===>100
Rollen<===>20
ChunGe<===>100
Rollen<===>20
ChunGe<===>100
Rollen<===>20
ChunGe<===>100
Rollen<===>20
ChunGe<===>100
Rollen<===>20
ChunGe<===>100
Rollen<===>20
ChunGe<===>100
Rollen<===>20
先在看结果就可以知道，之前的问题完全解决。







上一篇：单例模式singleton Pattern
下一篇：浅谈struts框架

文章评论