java多线程基础

多线程基础

读书练习照猫画虎

 package Threadtest;

 import java.util.Date;
 import java.util.concurrent.ArrayBlockingQueue;
 import java.util.concurrent.BlockingQueue;
 import java.util.concurrent.locks.Condition;
 import java.util.concurrent.locks.Lock;
 import java.util.concurrent.locks.ReentrantLock;

 public class ThreadExerc {
     public static void main(String[] args) throws Exception{
         /*
          * join
          */
 //        new JoinThread("new thread").start();
 //        for(int i=0; i<100; i++){
 //            if(i==20){
 //                JoinThread jt = new JoinThread("Joined Thread");
 //                jt.start();
 //                jt.join();
 //            }
 //            System.out.println(Thread.currentThread().getName()+"--"+i);
 //        }
         /*
          * sleep
          */
         //testSleep();

         /*
          * yeild
          */
         //testYeild();

         /*
          * 传统线程间通信
          */
 //        Account ac = new Account("123456", 0);
 //        new DrawThread("取钱者甲", ac, 1000).start();
 //        new DrawThread("取钱者乙", ac, 1000).start();
 //        new DrawThread("取钱者丙", ac, 1000).start();
 //        new DepositThread("存钱者A", ac, 1000).start();
 //        new DepositThread("存钱者B", ac, 1000).start();
 //        new DepositThread("存钱者C", ac, 1000).start();
 //
         /*
          * 阻塞队列线程间通信---ArrayBlockingQueue
          */
         BlockingQueue<String> bq = new ArrayBlockingQueue<>(5);
         new Producer("工厂A", bq).start();
         new Producer("工厂B",bq).start();
         new Producer("工厂C",bq).start();
         new Consumer("客户A",bq).start();
         new Consumer("客户B",bq).start();
     }
     static void testSleep() throws Exception{
     int i = 1;
     while(i++<100){
         System.out.println("Current Time is : "+ new Date());
         Thread.sleep(10000);
     }

     }
     static void testYeild() {
         class TestY extends Thread{
             public TestY(String name){
                 super(name);
             }
             public void run(){
                 for(int i=0; i<100; i++){
                     System.out.println(getName() + "--" + i);
                     if(i==20) Thread.yield();
                 }
             }
         }
         TestY t1 = new TestY("higher one");
         TestY t2 = new TestY("lowwer one");
 //        t1.setPriority(Thread.MAX_PRIORITY);
 //        t2.setPriority(Thread.MIN_PRIORITY);
         t1.start();
         t2.start();

     }
 }

 class JoinThread extends Thread{
     public JoinThread(String name){
         super(name);
     }
     public void run(){
         for(int i=0; i<100; i++){
             System.out.println(getName()+"--"+i);
         }
     }
 }

 class Account{
     private String accountNo;
     private double ballance;
     private boolean flag = false;
     private final Lock lock = new ReentrantLock();
     private final Condition cond = lock.newCondition();
     public Account(String accountNo, double ballance) {
         super();
         this.accountNo = accountNo;
         this.ballance = ballance;
     }
     public String getAccountNo() {
         return accountNo;
     }
     public void setAccountNo(String accountNo) {
         this.accountNo = accountNo;
     }
     public double getBallance() {
         return ballance;
     }
 //    public synchronized void draw(double drawAmount){
     public void draw(double drawAmount){
         lock.lock();
         try{
             if(!flag ){
                 //wait();
                 cond.await();
             }else{
                 System.out.println(Thread.currentThread().getName()+" 取钱： "+drawAmount);
                 ballance -= drawAmount;
                 System.out.println("余额："+ballance);
                 flag = !flag;
                 //notifyAll();
                 cond.signalAll();
             }
         }catch(Exception e){
             e.printStackTrace();
         }finally{
             lock.unlock();
         }
     }
 //    public synchronized void deposit(double depositAmount){
     public void deposit(double depositAmount){
         lock.lock();
         try{
             if(flag){
 //                wait();
                 cond.await();
             }else{
                 System.out.println(Thread.currentThread().getName()+" 存钱： "+depositAmount);
                 ballance += depositAmount;
                 System.out.println("余额："+ballance);
                 flag = !flag;
 //                notifyAll();
                 cond.signalAll();
             }
         }catch(Exception e){
             e.printStackTrace();
         }finally{
             lock.unlock();
         }
     }

 }
 class DrawThread extends Thread{
     private Account ac;
     private double drawAmount;
     public DrawThread(String name , Account ac, double drawAmount){
         super(name);
         this.ac = ac;
         this.drawAmount = drawAmount;
     }
     public void run(){
         for(int i=0; i<100; i++){
             ac.draw(drawAmount);
             System.out.println(super.getName()+","+i);
         }
     }
 }
 class DepositThread extends Thread{
     private Account ac;
     private double depositAmount;
     public DepositThread(String name , Account ac, double depositAmount){
         super(name);
         this.ac = ac;
         this.depositAmount = depositAmount;
     }
     public void run(){
         for(int i=0; i<100; i++){
             ac.deposit(depositAmount);
             System.out.println(super.getName()+","+i);
         }
     }
 }

 //================================
 class Producer extends Thread{
     private BlockingQueue<String> bq;

     public Producer(String name, BlockingQueue<String> bq) {
         super(name);
         this.bq = bq;
     }
     public void run(){
         String[] strArr = new String[]{
                 "java",
                 "Spring",
                 "struts",
                 "batis"
         };
         for(int i=0; i<1000; i++){
             System.out.println(getName()+"生产者准备生产集合元素!");
             try {
                 Thread.sleep(200);
                 bq.put(strArr[i%4]);
             } catch (InterruptedException e) {
                 // TODO Auto-generated catch block
                 e.printStackTrace();
             }
             System.out.println(getName()+"生产者完成!"+bq);
         }
     }
 }
 class Consumer extends Thread{
     private BlockingQueue<String> bq;

     public Consumer(String name, BlockingQueue<String> bq) {
         super(name);
         this.bq = bq;
     }
     public void run(){
         while(true){
             System.out.println(getName()+"消费者准备消费集合元素!");
             try {
                 Thread.sleep(200);
                 bq.take();
             } catch (InterruptedException e) {
                 // TODO Auto-generated catch block
                 e.printStackTrace();
             }
             System.out.println(getName()+"消费者完成!"+bq);
         }
     }
 }