七、多线程

一、概念：

1.程序、进程、线程

程序：一段静态代码块；

进程：正在运行的程序；系统会为每个进程分配内存空间
线程：程序内部的一条执行路径，若一个进程同一时间并行执行多个线程，就是支持多线程；
　　 一个进程中的多个线程共享同一个内存单元/内存地址空间（他们从同一堆中分配对象，可以访问相同的变量和对象（因为线程之间共享方法去和堆），就使得线程通信更简便高效，注意线程之间共享方法去和堆，其他不共享），但是多个线程共享的系统资源可能会带来安全隐患；

2.单核CPU和多核cup；

　　单核CPU的多线程：一个假的多线程，在一个单位时间内，也只能执行一个线程任务。例如收费站收费的工作人员，虽然多个车道，但是只有一个收费人员，当有车不想缴费时，工作人员挂起该车辆，同时给其他车辆做收费；这么个道理；
 
　　多核CPU：才能更好的发挥多线程的效率； 一个java应用程序，至少有3个线程：main（） 主线程和gc()和异常；
 
使用多线程的优点；以单核为例；
　　如果 需要c盘文件 复制到 D盘 e盘文件复制到 f盘 方式一、先复制c->d 然后 e->f 方式二：c->d 同时
e->f 此时 方式一更快；

　　如果是多核cpu，那么方式二更快；因为单核CPU执行多个线程，则需要切换不同的线程需要花费时间；二多核cpu呢，他不需要切换线程，则方式二就更快了；   

3.什么时候需要用到多线程：

a.程序需要同时执行两个或者多个任务， b..程序需要实现一些需要等待的任务时，如用户输入、文件读写操作、网络操作、搜索等；  c.需要一些后台运行的程序

4.并行 和 并发 并行：

多个CPU同时执行多个任务，多个人做不同的事情； 并发：一个CPU同时指向多个任务；

回到顶部

二、创建多线程的4中方式

1、继承Thread方式：

a1.创建一个继承Thread的子类，

a2.重写run方法；

a3.创建Thread子类的对象，通过此对象 调用start方法；start的作用：使得线程begin，调用当前线程的run方法；

例1：

///1.创建一个继承 Thread的子类；
class SubThread1 extends Thread {
    // 2.重写Thread类的run方法，方法内实现此子线程要完成的功能
    public void run() {
        for (int i = 1; i < 101; i++) {
            try {
                if(i%2 ==0) {
                    System.out.println(Thread.currentThread().getName() + ":" + i);
                }
                Thread.currentThread().sleep(1000);//休息一秒钟
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
            
        }
    }
}

public class Day18CreateThreadByExtendsThread13 {
    public static void main(String[] args) {

        
//        
        //3.创建一个子类的对象
        SubThread1 st = new SubThread1();
        //4.调用线程的start方法，启动此线程;再调用run方法(一个线程只能执行一次start()，可以创建两个对象来分别执行start方法！)
        st.start();//start 使得子线程begin 然后执行run方法；
        //再启动一个线程，则需要重新创建一个子类对象，再执行start方法。
        SubThread1 st1= new SubThread1();
        st1.start();
        System.out.println(Thread.currentThread().getName()+":hello!");//主线程内打印“hello”
    }
    
    
}

 

2、实现runnable 接口方式

b1.创建一个实现Runnable接口的类，

b2.重写run方法；

...

例2：

public class Day18CreateThreadByRunnableInterface13 {

    public static void main(String[] args) {
    //3创建一个Runnable接口实现类的对象
        PrintNum2 pn = new PrintNum2();
    //要想启动一个多线程，必须调用start
    //4将实现类对象作为形参传递给Thread类的构造器中，创建Thread类的对象，此对象即为一个线程
            Thread t1 = new Thread(pn);
    //启动线程，执行Thread对象生成时构造器形参的对象
    //5调动start，启动线程执行run方法
            t1.start();
    //再创建一个线程
            Thread t2 = new Thread(pn);
            t2.start();
    }
}

//1创建一个实现了Runnable接口类
class PrintNum2 implements Runnable {
//2实现接口的抽象方法
    public void run() {
        for (int i = 1; i < 101; i++) {
            System.out.println(Thread.currentThread().getName() + ":" + i);
        }
    }
}

3.实现callable接口方式

c1.创建一个实现Runnable接口的类，

c2.重写call方法；

c3.创建 callable接口实现类的对象

c4.将callable 接口实现类的对象 放入 Future中

c5.将futuretask 放入 Thread构造器中，，创建thread对象，并启动线程

c6.获取返回值；

  如何理解理解实现callable接口方式创建多线程比实现runnable接口创建对现场方式强大？
  1.call方法可以有返回值；
  2.call方法可以抛出异常，别外面的操作捕获；
  3.支持泛型

例3

public class Day19CreatThreadByCallable18 {
    public static void main(String[] args) {
        //3创建 callable接口实现类的对象
        NumThread uumThread = new NumThread();
        //4.将callable 接口实现类的对象 放入 Future中
        FutureTask futureTask = new FutureTask(uumThread);
        //5.将futuretask 放入 Thread构造器中，，创建thread对象，并启动线程
        Thread thread  = new Thread(futureTask);
        thread.start();
        try {
            //6.获取返回值；
            //get方法的返回值，即为futuretask 构造器参数callable实现类重写的call()的返回值
            int sum =  (int)futureTask.get();
            System.out.println(sum);
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (ExecutionException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }
}
//1.创建一个实现callable的实现了
class NumThread implements Callable{
    //遍历100以内的偶数，并且返回和
    //2.重写 Call方法，将此线程需要执行的操作声明在call（）中，同事call（）方法可以有返回值
    @Override
    public Object call() throws Exception {
        int sum = 0;
        for(int i=1;i<=100;i++) {
            if(i%2 == 0) {
                sum = sum+i;
            }
        }
        return sum;
    }
}

4.使用线程池方式创建多线程；

d1.提供指定数量线程的线程池

d2.创建实现runnable接口的实现类 or 创建实现callable接口的实现类;

d3..执行指定线程的操作；

d4.关闭线程池

使用线程池：
  背景：经常创建和销毁、使用量特别大的资源，比如并发情况下的线程，对性能影响很大；
  思路：提前创建好多个线程，放入线程池中，使用时直接获取，使用完放回池中，可以避免频繁创建销毁、实现重复利用。类似生活中的公共交通工具；
  好处：
      提前响应速度、降低资源消耗、便于线程管理(
  corePoolSize :核心池的大小；
  MaximumPoolSize:最大线程数；
  keepAliveTime:线程没有任务时最多保持多长后会终止；
  );

例4：

public class Day19CreatThreadByPool19 {
    public static void main(String[] args) {
        //1.提供指定数量线程的线程池
        ExecutorService service = Executors.newFixedThreadPool(10);
        //其他：设置线程池的属性：
        ThreadPoolExecutor service1 = (ThreadPoolExecutor)service;
//        service1.setCorePoolSize(15);
        //2.创建实现runnable接口的实现类 or 创建实现callable接口的实现类
        NumberThread1 numThread1 = new NumberThread1();
        NumberThread2 numberThread2 = new NumberThread2();
        FutureTask  futureTask = new FutureTask(numberThread2);
        //3.执行指定线程的操作；
        service.execute(numThread1);//适合使用runnable
        service.submit(futureTask);//适合使用 callable方法
        //4.关闭连接池
        service.shutdown();//关闭连接池
    }
}
class NumberThread1 implements Runnable{
    @Override
    public void run() {
        int sum = 0;
        for(int i = 1;i<=100;i++) {
            if(i%2 == 0) {
                sum = sum +i;
                System.out.println(Thread.currentThread().getName()+":"+i);
            }
            
        }
        System.out.println("runnabl sum:"+sum);
        
    }
    
}

class NumberThread2 implements Callable{
    @Override
    public Object call() throws Exception {
        int sum = 0;
        for(int i = 1;i<=100;i++) {
            if(i%2 == 0) {
                sum = sum +i;
                
            }else {
                System.out.println(Thread.currentThread().getName()+":"+i);
            }
            
        }
        System.out.println("callable sum:"+sum);
        return sum;
    }
    
}

回到顶部

三、Thread的常用方法

 1.start()方法：1.begin 线程 ，2.调用当前线程的run方法；
 2.run()方法：需要重写Thread类中的此方法，将创建的线程哟啊执行的操作声明在此方法中
 3.currentThread();返回一个Threan 当前执行代码的线程；
 4.getName();获取当前线程的名称
 5.setName()：设置当前线程的名字 注意在 start前面
 6.yield():释放当前cpu的执行权
 7.join();在线程a中调用线程b的join(),此时a就进入了阻塞状态，知道b完全指向完以后，a才结束阻塞状态；
 8.stop();强制结束当前线程；已过期
 9.sleep();让当前线程“睡眠”指定的millitime毫秒，在指定的millitime毫秒时间内，当前线程是阻塞状态；
 10.isAlive():判断当前线程是否存活；当线程执行完成后，则线程死亡；
 

public class Day18ThreadMethods {

    public static void main(String[] args) {
        ThreadTest1 test1 = new ThreadTest1();
        ThreadMethods2 test2 = new ThreadMethods2("线程2");
        test1.setName("线程1");
        test1.start();
        test2.start();
        for(int i=0;i<100;i++) {
            if(i%10 == 0) {
                System.out.println(Thread.currentThread().getName()+":"+i);
            }
            if(i==20) {
                try {
                    test1.join();
                } catch (InterruptedException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
            }
            System.out.println(test1.isAlive());
            
        }
        
    }
}

class ThreadMethods1 extends Thread{
    @Override
    public void run() {
        try {
            sleep(1000);//阻塞一秒；sleep在此时只能使用 try catch,why？因为run的父类方法没有抛异常，所以子类就不能抛异常
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }//睡眠1秒
        // TODO Auto-generated method stub
        for(int i=0;i<100;i++) {
            if(i%2 == 0) {
                System.out.println(Thread.currentThread().getName()+":"+i);
            }
            if(i%20 == 0) {
                yield();
            }
            
        }
    }
    public ThreadMethods1(String name) {
        super(name);
    }
}
class ThreadMethods2 extends Thread{
    @Override
    public void run() {
        // TODO Auto-generated method stub
        for(int i=0;i<100;i++) {
            if(i%2 != 0) {
                System.out.println(Thread.currentThread().getName()+":"+i);
            }
            
        }
    }
    public ThreadMethods2(String name) {
        super(name);
    }
}

回到顶部

四、线程的调度

时间片
 抢占式：高优先级的线程抢占cpu
 java的调度方法：
 同优先级的组成先进先出队列（先到先服务），使用时间片服务；
 对高优先级，使用优先调度的抢占式策略；
 
 线程的优先等级：
 MAX_PRIORITY:10
 MIN_PRIORITY:1;
 NORM_PRIORITY:5
 方法：
 getPriority():返回线程的优先等级值
 setPriority():设置线程的优先等级值；
 
 说明：高优先级的线程要抢占低优先级CPU执行次序，但是只是从概率上讲，高概率上执行，并不意味着只有当高优先级的线程执行完以后，低优先级的线程才执行

public class Day18Priority17 {
public static void main(String[] args) {
    System.out.println(Thread.currentThread().getName()+":"+Thread.currentThread().getPriority());//获取主线程的优先等级值 5
    ThreadPriority test = new ThreadPriority();
    test.setPriority(10);//设置分线程的优先级
    test.start();
    for(int i=0;i<100;i++) {
        
        System.out.println(Thread.currentThread().getName()+":"+i);
    }
}
}

class ThreadPriority extends Thread{
    @Override
    public void run() {
        for(int i=0;i<100;i++) {
            System.out.println(Thread.currentThread().getName()+":"+i);
        }
        super.run();
    }

回到顶部

五、线程安全

1.线程安全 产生背景：

例5场景是，3个窗口同时卖火车票（共100张）；出现的问题是：不同窗口可能出现相同的票号；可能会卖出错票（即出现了-1号票等情况）：

原因：当某线程操作车票时，操作尚未完成，其他线程参与进来，也操作车票导致；

 

 

 

 

 

 

 

 

 

 

 

 

 

解决：当一个线程在操作ticket，其他线程不能参与进来，知道该线程操作完了，其他线程才可以开始操作ticket，这种情况即使该线程出现阻塞，也不能被改变；
在java中，我们通过同步机制来解决线程的安全问题；

例5：

/
  例子：创建3个买票窗口卖票
  @Description        
@author            lixiuming
@version    
  @date            2020年12月22日下午7:43:25            
 创建线程的两种方式的比较：
 开发中优先选择实现runnable接口；
 原因：实现方式没有类的单继承的局限性
         实现方式更实现多个线程的有共享数据的情况
 联系：Thread也实现了runnable接口
 两种方式都需要重写run方法，将逻辑代码都写在run（）方法中；
 java 程序至少有3个线程；一个是主线程 一个是gc()垃圾回收线程，异常处理线程；
 /
public class Day18WindowTest18 {
    public static void main(String[] args) {
//        Window window1 = new Window();
//        Window window2 = new Window();
//        Window window3 = new Window();
//        window1.start();
//        window2.start();
//        window3.start();
        WindowbyRunnable windowbyRunnable = new WindowbyRunnable();
        Thread wr1 = new Thread(windowbyRunnable);
        Thread wr2 = new Thread(windowbyRunnable);
        Thread wr3 = new Thread(windowbyRunnable);
        wr1.start();
        wr2.start();
        wr3.start();
        
                
    }
}


//继承Thread 方式实现 窗口卖票
class Window extends Thread{
    private static int ticket = 100;
    @Override
    public void run() {
        // TODO Auto-generated method stub
        while(true) {
            if(ticket>0) {
                System.out.println(Thread.currentThread().getName()+":"+ticket);
                ticket--;
            }else {
                break;
            }
        }
    }}

//使用runnable接口方式实现窗口
    class WindowbyRunnable implements Runnable{
        private  int ticket = 100;
        @Override
        public void run(){
            // TODO Auto-generated method stub
            while(true) {
                if(ticket>0) {
                    System.out.println(Thread.currentThread().getName()+":"+ticket);
                    ticket--;
                }else {
                    break;
                }
        }
        
    }    
    }

 2.同步块|同步方法 解决线程安全：

方式一：同步代码块 1.synchronized(同步监视器){ 需要被同步的代码 }; 说明：
1.操作共享数据的代码就是 需要被同步的代码；不能包含代码多了，也不能包含少了；

2.共享数据：多个线程操作的变量；比如本问题的ticket
3.同步监视器：俗称锁；任何类的对象都可以充当锁；(一定保证所有线程共用一个锁，也就是说作为锁的类只能保证只被创建过一次)
补充：在实现runnable接口创建多线程方式中，可以考虑使用this 来充当同步监视器；

说明，在继承Thread创建多线程方式中，慎用this充当，可以考虑当前类来充当同步监视器；

方式二：同步方法 如果操作共享数据的代码完整的声明在一个方法中，我们不妨将此方法声明同步的；

 说明：
  使用同步方法来解决实现runnable接口的线程安全问题；
  关于同步方法的总结：
  1.同步方法仍然涉及到同步监视器，只是不需要我们现实的声明。
  2.非静态的同步方法：同步监视器是this；
      静态的同步方法：同步监视器是当前类本身；

例6（同步代码块方式）

public class Day19ThreadSafe6 {
    public static void main(String[] args) {
        WindowOfSaleTicket windowOfSaleTicket = new WindowOfSaleTicket();
        Thread thread1 = new Thread(windowOfSaleTicket);
        Thread thread2 = new Thread(windowOfSaleTicket);
        Thread thread3 = new Thread(windowOfSaleTicket);
        thread1.start();
        thread2.start();
        thread3.start();
    }
}

class WindowOfSaleTicket implements Runnable {
    private int ticketcount = 100;
    Object obj = new Object();

    @Override
    public void run() {

        while (true) {
            synchronized (obj) {// obj 可以用 this来充当，this代表当前对象，即windowOfSaleTicket
                if (ticketcount > 0) {
                    try {
                        Thread.sleep(100);
                        System.out.println(Thread.currentThread().getName() + ":" + ticketcount);
                        ticketcount--;
                    } catch (InterruptedException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    }
                } else {

                    break;
                }

            }
        }

    }
}

例7（同步方法：）

public class Day19ThreadSafe8 {
public static void main(String[] args) {
    WindowOfSaleTicket1 windowOfSaleTicket = new WindowOfSaleTicket1();
    Thread thread1 = new Thread(windowOfSaleTicket);
    Thread thread2 = new Thread(windowOfSaleTicket);
    Thread thread3 = new Thread(windowOfSaleTicket);
    thread1.start();
    thread2.start();
    thread3.start();
}
}

class WindowOfSaleTicket1 implements Runnable{
    private int ticketcount = 100;
    Object obj = new Object();
    @Override
    public  void run() {
        while (true) {
            show();
        }    
        
    }
    
    public synchronized void show() {
        if (ticketcount > 0) {
            try {
                Thread.sleep(100);
                System.out.println(Thread.currentThread().getName() + ":" + ticketcount);
                ticketcount--;
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        } 
    }
    
}

3.使用Lock方式解决线程安全问题：

解决线程安全问题的方式三：Lock锁，JDK5.0新增的方式；
面试题：synchronized 与Lock的异同？
同：二者都是解决线程安全的；
不同：synchronized 在执行完代码后，自动释放同步监视器，Lock需要手动的锁定和手动的解锁；

线程安全的解决方式：
1.同步sychronized :同步代码块 和 同步方法；
2.Lock的方式

例8：

public class Day19CreateThreadSafeLock13 {
public static void main(String[] args) {
    WindowOfSaleTicket2 windowOfSaleTicket = new WindowOfSaleTicket2();
    Thread thread1 = new Thread(windowOfSaleTicket);
    Thread thread2 = new Thread(windowOfSaleTicket);
    Thread thread3 = new Thread(windowOfSaleTicket);
    thread1.start();
    thread2.start();
    thread3.start();
}
}

class WindowOfSaleTicket2 implements Runnable{
    //实例化Lock
    private ReentrantLock lock = new ReentrantLock();
    
    
    
    private int ticketcount = 100;
    Object obj = new Object();
    @Override
    public  void run() {
        while (true) {
            try {
                
                //调用lock方法 锁定
                lock.lock();
                show();
                
            }finally {
                //解锁
                lock.unlock();
            }
            
        }    
        
    }
    
    public  void show() {
        if (ticketcount > 0) {
            try {
                Thread.sleep(100);
                System.out.println(Thread.currentThread().getName() + ":" + ticketcount);
                ticketcount--;
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        } 
    }
    
}

4.线程安全使用案例：

有两个储户分别向一个账户存3000元，每次存1000，存3次，每次存完打印账户余额；

public class Day19ThreadQuestion14 {
public static void main(String[] args) {
    BankCount bankCount = new BankCount();
    Thread thread1 = new Thread(bankCount);
    Thread thread2 = new Thread(bankCount);
    thread1.setName("甲");
    thread2.setName("乙");
    thread1.start();
    thread2.start();
}
}
class BankCount implements Runnable{
    double account = 0;
    int count = 0;
    @Override
    public void run() {
        while(true) {
            try {
                Thread.sleep(200);
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
            addAccount(1000);
            
            
        }
        
        
    }
    private synchronized double addAccount(double mony) {
        if(count<3) {
            account += mony;
            System.out.println(Thread.currentThread().getName()+"存完后的余额:"+account+",count:"+count);
            
            count++;
            
        }
        
        return account;
    }
    
}

5.线程安全的单例模式

public class Bank{
　　private Bank(){
　　}
　　public static Bank instance = null;
　　public static Band getInstance(){
　　 　　if(instance == null){
  　　　　synchronized(Bank.class){
    　　　　　instance = new Bank();
　　　　　　}
　　　　} 　　　　　　
        return  instance;
　　}
}    

回到顶部

六、线程的生命周期：

  1.创建；Thread类 or 子类的对象声明并创建时，新生线程对象处于新建状态 MyThread thread = new MyThread();
  2.就绪；调用start thread.start();
  3.运行；就绪的线程被CPU调度并获得cpu资源，那么就是进入了运行状态；
  4.阻塞；让出CPU并临时中断自己的执行，就是进入了阻塞状态；
  5.死亡；线程完成了它的全部工作或被强制终止or遇到异常导致结束；

回到顶部

七、线程的通信：

涉及到的3个方法：
  1.wait():一旦执行此方法，当前线程就处于阻塞状态；并释放同步监视器
  2.notify()：一旦执行此方法：就会唤醒的一个被wait()的方法，如果有多个线程被wait(),就唤醒优先级高的；
  3.notifyAll()：一旦执行此方法：就会唤醒的所有被wait()的方法，
  说明：
  1.线程通信这3个方法，都得在同步代码块或者同步方法中，；
  2.线程通信这3个方法调用者必须是同步代码块或者是同步方法中的同步监视器，否则出异常；
  3.线程通信这3个方法，定义在object类中的 java.long.object
 线程通信例子：打印1-100，线程1 线程二 交替打印；

public class Day19ThreadCommunication15 {
public static void main(String[] args) {
    Communication1 communication1 = new Communication1();
    Thread thread1 = new Thread(communication1);
    Thread thread2 = new Thread(communication1);
    thread1.setName("甲");
    thread2.setName("乙");
    thread1.start();
    thread2.start();
}
}
class Communication1 implements Runnable{
    int count = 1;
    @Override
    public void run() {
        while(true) {
            try {
                Thread.sleep(200);
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
            printNum();
            
            
        }
        
        
    }
    private synchronized void printNum() {
        
        if(count<101) {
                System.out.println(Thread.currentThread().getName()+":"+count);
                count++;
                notify();
                try {
                    wait();
                } catch (InterruptedException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }            
            
            
        }
        
    }
    
}

  面试题：
  sleep 和 wait的异同
  同：都会使得当前线程进入阻塞状态；
  异：.
  1.两个方法定义的位置不同；Thread 类中声明sleep();object中声明了wait();
  2.调用的范围不同，sleep（）可以在任何需要的位置调用，wait()必须在同步代码块or方法中；
  3.如果两个方法都使用在同步代码块or同步方法中，sleep不会是否同步监视器；wait()会释放同步监视器

回到顶部

八、死锁：

  使用同步机制改写单例模式的懒汉式，改写为线程安全
  1.死锁的理解：不同的线程 占用 对方的需要的同步资源不放弃，都在等待对方放弃自己需要的同步资源就形成了死锁
  2.说明：出现死锁后，不会抛出异常，不会提示，只是所有的线程都处于阻塞状态；
  我们使用同步时，要避免死锁；
  解决方法：
  1.专门的算法、原则
  2.尽量减少同步资源的定义；
  3.尽量避免嵌套同步方法；

回到顶部

九、综合例子：

  面试题：
  生产者（Productor）将产品交到店员（clerk）,而消费者（Customer）从店员处取走产品，店员一次只能持有
  固定数量的产品（比如20），如果生产者视图生产更多的产品，店员就好叫生产者停一下，如果点店中有了空位放产品了
  在通知生产者继续生产，如果店中没有产品了，店员会告诉消费者等一下，如果店中有产品了在通知消费者取走产品；
  分析：
  是否是多线程问题：生产者线程；消费者线程
  是否有线程安全问题：共享数据是 ”产品数“
  如何解决安全问题，synchronize的两张方法 or lock;
  是否需要线程的通信 ：是

public class Day19ThreadQuestionProductorAndConsumer17 {
public static void main(String[] args) {
    ProductorAndConsumer productorAndConsumer = new ProductorAndConsumer();
    Thread Productor = new Thread(productorAndConsumer);
    Thread Comsumer = new Thread(productorAndConsumer);
    Productor.setName("生产者");
    Comsumer.setName("消费者");
    Productor.start();
    Comsumer.start();
}
}
class ProductorAndConsumer implements Runnable{
    int account = 0;
    @Override
    public void run() {
        while(true) {
            try {
                Thread.sleep(2000);
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
            addAccount();
            
            
        }
        
        
    }
    private synchronized double addAccount() {
        notify();
        String currentName = Thread.currentThread().getName();
        if(account==0) {
            
            if(currentName.equals("消费者")) {
                try {
                    System.out.println("account:"+account+",消费者阻塞");
                    wait();
                } catch (InterruptedException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
            }else {
                account = account+1;
                System.out.println("account:"+account+",生产者生产第："+account+"个产品！");
                
            }
            
        }else if(account==20) {
            if(currentName.equals("生产者")) {
                try {
                    System.out.println("account:"+account+",生产者阻塞");
                    wait();
                } catch (InterruptedException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
                
            }else {
                account = account-1;
                System.out.println("account:"+account+",消费者消费第："+account+"个产品！");
                
            }
            
        }else {
            if(currentName.equals("生产者")) {
                account++;
                System.out.println("account:"+account+",生产者生产第："+account+"个产品！");
                
                
            }else {
                
                System.out.println("account:"+account+",消费者消费第："+account+"个产品！");
                account--;
            }
            
        }
        
        
        return account;
    }
    
}

public class Day19ThreadQuestionProductorAndConsumer17_2 {
public static void main(String[] args) {
    Clerk clerk = new Clerk();
    Productor productorAndConsumer = new Productor(clerk);
    Consummer comsumer = new Consummer(clerk);
    Thread Productor = new Thread(productorAndConsumer);
    Thread Comsumer = new Thread(comsumer);
    Productor.setName("生产者");
    Comsumer.setName("消费者");
    Productor.start();
    Comsumer.start();
}
}
class Productor implements Runnable{
    private Clerk clert;
    
    public Productor(Clerk clert) {
        this.clert = clert;
    }

    @Override
    public void run() {
        while(true) {
            try {
                Thread.sleep(2000);
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
            clert.addAccount();
        }
        
        
    }
    
}
class Consummer implements Runnable{
    private Clerk clerk ;
    
    public Consummer(Clerk clerk) {
        this.clerk = clerk;
    }

    @Override
    public void run() {
        while(true) {
            try {
                Thread.sleep(2000);
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
            clerk.addAccount();
            
            
        }
        
        
    }
    
}
class Clerk{
    private int account=0;    

    public synchronized double addAccount() {
        notify();
        String currentName = Thread.currentThread().getName();
        if(account==0) {
            
            if(currentName.equals("消费者")) {
                try {
                    System.out.println("account:"+account+",消费者阻塞");
                    wait();
                } catch (InterruptedException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
            }else {
                account = account+1;
                System.out.println("account:"+account+",生产者生产第："+account+"个产品！");
                
            }
            
        }else if(account==20) {
            if(currentName.equals("生产者")) {
                try {
                    System.out.println("account:"+account+",生产者阻塞");
                    wait();
                } catch (InterruptedException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
                
            }else {
                account = account-1;
                System.out.println("account:"+account+",消费者消费第："+account+"个产品！");
                
            }
            
        }else {
            if(currentName.equals("生产者")) {
                account++;
                System.out.println("account:"+account+",生产者生产第："+account+"个产品！");
                
                
            }else {
                
                System.out.println("account:"+account+",消费者消费第："+account+"个产品！");
                account--;
            }
            
        }
        
        
        return account;
    }
    
}