java 多线程之synchronized wait/notify解决买票问题

一.Java线程具有五中基本状态

新建状态（New）：当线程对象对创建后，即进入了新建状态，如：Thread t = new MyThread();

就绪状态（Runnable）：当调用线程对象的start()方法（t.start();），线程即进入就绪状态。处于就绪状态的线程，只是说明此线程已经做好了准备，随时等待CPU调度执行，并不是说执行了t.start()此线程立即就会执行；

运行状态（Running）：当CPU开始调度处于就绪状态的线程时，此时线程才得以真正执行，即进入到运行状态。注：就     绪状态是进入到运行状态的唯一入口，也就是说，线程要想进入运行状态执行，首先必须处于就绪状态中；

阻塞状态（Blocked）：处于运行状态中的线程由于某种原因，暂时放弃对CPU的使用权，停止执行，此时进入阻塞状态，直到其进入到就绪状态，才 有机会再次被CPU调用以进入到运行状态。根据阻塞产生的原因不同，阻塞状态又可以分为三种：

1.等待阻塞：运行状态中的线程执行wait()方法，使本线程进入到等待阻塞状态；

2.同步阻塞 -- 线程在获取synchronized同步锁失败(因为锁被其它线程所占用)，它会进入同步阻塞状态；

3.其他阻塞 -- 通过调用线程的sleep()或join()或发出了I/O请求时，线程会进入到阻塞状态。当sleep()状态超时、join()等待线程终止或者超时、或者I/O处理完毕时，线程重新转入就绪状态。

死亡状态（Dead）：线程执行完了或者因异常退出了run()方法，该线程结束生命周期。

二. Java多线程的创建及启动

1.继承Thread类，重写该类的run()方法。

两个线程同时运行，随机产生4位随机字符

 import java.util.Random;

 public class 多线程 {

     public static Object lock = new Object();

     public static void randomString() {
         String str = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";
         Random random = new Random();
         StringBuffer sb = new StringBuffer();
         for (int i = 0; i < 4; i++) {
             int number = random.nextInt(62);
             sb.append(str.charAt(number));
         }
         System.out.print(sb);
     }

     public static void main(String[] args) {

         new Thread(new myTh1()).start();
         new Thread(new myTh2()).start();

     }

 }

 class myTh1 extends Thread {
     @Override
     public void run() {
         while (true) {

             try {
                 synchronized (多线程.lock) {
                     多线程.randomString();
                     System.out.print("------"+Thread.currentThread().getName());
                     System.out.println();
                 }
                 sleep(1000);
             } catch (InterruptedException e) {
                 e.printStackTrace();
             }
         }
     }
 }

 class myTh2 extends Thread {
     @Override
     public void run() {
         while (true) {
             try {
                 synchronized (多线程.lock) {
                     多线程.randomString();
                     System.out.print("------"+Thread.currentThread().getName());
                     System.out.println();
                 }
                 sleep(1000);
             } catch (InterruptedException e) {
                 e.printStackTrace();
             }
         }
     }
 }

2.实现Runnable接口，并重写该接口的run()方法，该run()方法同样是线程执行体，创建Runnable实现类的实例，并以此实例作为Thread类的target来创建Thread对象，该Thread对象才是真正的线程对象

主线程和两个实现Runnable接口的线程同时运行，线程对象只运行5次。

 public class 多线程Runnable {

     public static void main(String[] args) {
         System.out.println(Thread.currentThread().getName());
         try {
             Thread.sleep(3000);
         } catch (InterruptedException e) {
             e.printStackTrace();
         }

         new Thread(new myTh3()).start();
         new Thread(new myTh4()).start();

     }
 }
     class myTh3 extends Thread{
         int i=0;
         @Override
         public void run() {
             while (i<5) {
                 System.out.println(Thread.currentThread().getName());
                 try {
                     sleep(2000);
                 } catch (InterruptedException e) {
                     e.printStackTrace();
                 }
                 i++;
             }

         }

     }

     class myTh4 implements Runnable{

         int i=0;
         @Override
         public void run() {
             while (i<5) {
                 System.out.println(Thread.currentThread().getName());
                 i++;
             }

     }
 }

3.synchronized, wait, notify结合:

解决问题三个人去买票，张某有20元，李某10元。赵某5元。电影票5元一张，售货员只有3张5元的

 /*问题：
  * 三个人去买票，张某有20元，李某10元。赵某5元。
  * 电影票5元一张，售货员只有3张5元的。
  *
  * 思路：
  * 张某买了票就会少3张5元的
  * 李某买了票就会少1张5元的
  * 赵某买了票就会多1张5元的
  * 所以有三种情况：
  * 一。赵某先买，张李都可以买
  * 二。张某先买，此时李某买不了，只能等待赵某买了，再买
  * 三。李某先买，此时张某买不了，只能等待赵某买了，再买
  *
  * 静态常量：售货员总钱数 sum=3
  *
  *     1.创建三个线程分别为张某，李某，赵某
  *     2.判断此时sum值，合适就买票，减去相应的钱数，不合适就等待。
  */
 import java.util.ArrayList;
 import java.util.Iterator;
 import java.util.List;

 public class 多线程3 {

     public static int sum = 3;//设置零钱总张数为3张
     public static Object look = new Object();//建立一个锁

     public static List<Thread> arrayList = new ArrayList<>();//建立集合 保存这三个购买人的线程

     public static void main(String[] args) throws InterruptedException {
         //随机将赵某李某张某添加到集合中
         arrayList.add(new li());
         arrayList.add(new zhang());
         arrayList.add(new zhao());

         //通过迭代器遍历集合
         Iterator<Thread> iterator = arrayList.iterator();

         while (iterator.hasNext()) {
             //获取线程
             Thread t = iterator.next();
             //线程启动
             t.start();
             //线程睡眠
             t.sleep(2000);
         }

     }
 }
 /**
  * 张某线程
  * @author Administrator
  *
  */
 class zhang extends Thread {
     @Override
     public void run() {
         //因为要判断等待和唤醒，并且操作sum，所以在此处加锁
         synchronized (多线程3.look) {
             while (多线程3.sum < 3) {
                 try {
                     System.out.println("因为此时零钱不足："+多线程3.sum+"张");
                     System.out.println("所以张某没买到电影票，等待购买");
                     多线程3.look.wait();
                 } catch (InterruptedException e) {
                     e.printStackTrace();
                 }
             }  if (多线程3.sum > 2) {
                 多线程3.sum = 多线程3.sum - 3;
                 多线程3.look.notify();
                 System.out.println("张某买到了电影票");
                 System.out.println("此时零钱数为："+多线程3.sum+"张");
             }
         }
     }
 }
 /**
  * 李某线程
  * @author Administrator
  *
  */
 class li extends Thread {
     @Override
     public void run() {
         synchronized (多线程3.look) {
             while (多线程3.sum < 1) {
                 try {
                     System.out.println("因为此时零钱不足："+多线程3.sum+"张");
                     System.out.println("所以李某没买到电影票，等待购买");
                     多线程3.look.wait();
                 } catch (InterruptedException e) {
                     e.printStackTrace();
                 }
             }  if (多线程3.sum >= 1) {
                 多线程3.sum = 多线程3.sum - 1;
                 多线程3.look.notify();
                 System.out.println("李某买到了电影票");
                 System.out.println("此时零钱数为："+多线程3.sum+"张");
             }

         }
     }
 }
 /**
  * 赵某线程
  * @author Administrator
  *
  */
 class zhao extends Thread {
     @Override
     public void run() {
         synchronized (多线程3.look) {
             if (多线程3.sum >= 0) {
                 多线程3.sum = 多线程3.sum + 1;
                 System.out.println("赵某买到了电影票");
                 System.out.println("此时零钱数为："+多线程3.sum+"张");
                 多线程3.look.notify();
             }
         }
     }
 }

全部都是培训课后习题，最后一个足足搞了半天，希望我写的没毛病，求指教。。谢谢大佬。