路人

导航

<2024年11月>
日一二三四五六
272829303112
3456789
10111213141516
17181920212223
24252627282930
1234567

统计

常用链接

留言簿

随笔档案(39)

相册

搜索

积分与排名

最新评论

阅读排行榜

评论排行榜

JAVA多线程

package  com.thread;

 public   class  SyncTest  {
     public   static   void  main(String args[])  {
        SyncStack stack  =   new  SyncStack();
         //  下面的消费者类对象和生产者类对象所操作的是同一个同步堆栈对象
        Runnable source  =   new  Producer(stack);
        Runnable sink  =   new  Consumer(stack);
        Thread t1  =   new  Thread(source);  //  线程实例化
        Thread t2  =   new  Thread(sink);  //  线程实例化
        t1.start();  //  线程启动
        t2.start();  //  线程启动
    }
}

class  SyncStack  {  //  同步堆栈类
     private   int  index  =   0 ;  //  堆栈指针初始值为0

     private   char [] buffer  =   new   char [ 6 ];  //  堆栈有6个字符的空间

     public   synchronized   void  push( char  c)  {  //  加上互斥锁
         while  (index  ==  buffer.length)  { //  堆栈已满，不能压栈
             try   {
                 this .wait();  //  等待，直到有数据出栈
            }   catch  (InterruptedException e)  {
            }
        }
         this .notify();  //  通知其它线程把数据出栈
        buffer[index]  =  c;  //  数据入栈
        index ++ ; //  指针向上移动
    }

     public   synchronized   char  pop()  { //  加上互斥锁
         while  (index  ==   0 )  { //  堆栈无数据，不能出栈
             try   {
                 this .wait(); //  等待其它线程把数据入栈
            }   catch  (InterruptedException e)  {
            }
        }
         this .notify(); //  通知其它线程入栈
        index -- ; //  指针向下移动
         return  buffer[index]; //  数据出栈
    }
}

class  Consumer  implements  Runnable  {  //  消费者类
    SyncStack theStack;  //  消费者类获得的字符都来自同步堆栈

     public  Consumer(SyncStack s)  {
        theStack  =  s;
    }

     public   void  run()  {
         char  c;
         for  ( int  i  =   0 ; i  <   20 ; i ++ )  {
            c  =  theStack.pop();  //  从堆栈中读取字符
            System.out.println( " Consumed:  "   +  c); //  打印字符
             try   {
                Thread.sleep(( int ) (Math.random()  *   1000 ));
                 /*  每读取一个字符线程就睡眠  */
            }   catch  (InterruptedException e)  {
                e.printStackTrace();
            }
        }
    }
}

class  Producer  implements  Runnable  {  //  生产者类
    SyncStack theStack;

     //  生产者类生成的字母都保存到同步堆栈中
     public  Producer(SyncStack s)  {
        theStack  =  s;
    }

     public   void  run()  {
         char  c;
         for  ( int  i  =   0 ; i  <   20 ; i ++ )  {
            c  =  ( char ) (Math.random()  *   26   +   ' A ' );  //  随机产生20个字符
            theStack.push(c);  //  把字符入栈
            System.out.println( " Produced:  "   +  c);  //  打印字符
             try   {
                Thread.sleep(( int ) (Math.random()  *   1000 ));
                 /*  每产生一个字符线程就睡眠  */
            }   catch  (InterruptedException e)  {
                e.printStackTrace();
            }
        }
    }
}

posted on 2006-03-18 14:50 山岗 阅读(253) 评论(0)  编辑 收藏 引用

只有注册用户登录后才能发表评论。