java 多线程-3

十、同步机制解决Thread继承安全问题

创建三个窗口买票，共100张票。用继承来实现

1. 方式一：同步代码块

   public class RunMainExtends {
       public static void main(String[] args) {
           Win win1 = new Win();
           Win win2 = new Win();
           Win win3 = new Win();
           // 设置线程的名字
           win1.setName("窗口一：");
           win2.setName("窗口二：");
           win3.setName("窗口三：");
           // 开启线程
           win1.start();
           win2.start();
           win3.start();
       }
   }
   
   /* 方式一：同步代码块*/
   class Win extends Thread {
       /*
       注意：ticket、object必须加static。因为实例化的三个线程对象，是不同的对象，他们各自有自己的栈和程序计数器。只有加了static才能让这个三个对象共享ticket、object。
       */
       private static int ticket = 100;
       private static Object object = new Object();
       @Override
       public void run() {
           while (true) {
               synchronized (object){// 同步代码块，同步监视器，必须是同一把锁
                   if (ticket > 0) {
                       try {
                           Thread.sleep(100);
                       } catch (InterruptedException e) {
                           e.printStackTrace();
                       }
                       System.out.println(Thread.currentThread().getName()+"获取到了第"+ticket+"票");
                       ticket--;
                   }else{
                       break;
                   }
               }
           }
       }
   }
   
   

2. 方式二：同步方法

   public class RunMainExtends {
       public static void main(String[] args) {
           Win win1 = new Win();
           Win win2 = new Win();
           Win win3 = new Win();
           // 设置线程的名字
           win1.setName("窗口一：");
           win2.setName("窗口二：");
           win3.setName("窗口三：");
           // 开启线程
           win1.start();
           win2.start();
           win3.start();
       }
   }
   
   /*方式二：同步方法
    * */
   class Win extends Thread {
       private static int ticket = 100;
       private static Object object = new Object();
       @Override
       public void run() {
           while (true) {
               show();
               if (ticket == 0) {
                   break;// 用于跳出循环
               }
           }
       }
   
       /* 定义一个同步方法,注意必须把这个方法定义为一静态方法
        * */
       private static synchronized void show() {
           if (ticket > 0) {
               try {
                   Thread.sleep(100);
               } catch (InterruptedException e) {
                   e.printStackTrace();
               }
               System.out.println(Thread.currentThread().getName()+"获取到了第"+ticket+"票");
               ticket--;
           }
       }
   }
   

   同步方法总结：

   /**
    * 同步机制解决“继承Thread类”的线程安问题
    * 关于同步方法的总结：
    * 1. 同步方法任然设计来到同步监视器，只是不需要我们显示的声明。
    * 2. 非静态同步方法，同步监视器是this
    * 3. 静态同步方法，同步监视器是类本身
    */
   

十一、线程的死锁问题

11.1 死锁简介

1. 不同的线程分别占用对方需要的同步资源不放弃，都在等待对方放弃自己需要的同步资源，就形成了线程的死锁。【如：有多把锁】
2. 出现死锁后，不会出现异常，不会出现提示，只是所有的线程都处于阻塞状态，无法继续

11.2 死锁解决方法

1. 专门的算法、原则

2. 尽量减少同步资源的定义

3. 尽量避免嵌套同步

4. 写代码时，要尽量避免死锁

十二、方式三：Lock(锁)

12.1 Lock简介

1. 从JDK 5.0开始，Java提供了更强大的线程同步机制——通过显式定义同步锁对象来实现同步。同步锁使用Lock对象充当。
2. java.util.concurrent.locks.Lock接口是控制多个线程对共享资源进行访问的工具。锁提供了对共享资源的独占访问，每次只能有一个线程对Lock对象加锁，线程开始访问共享资源之前应先获得Lock对象。
3. ReentrantLock类实现了Lock，它拥有与synchronized相同的并发性和内存语义，在实现线程安全的控制中，比较常用的是ReentrantLock，可以显式加锁、释放锁。

总结：Lock锁是java在5.0之后提出来的一种线程同步机制，我们可以把它 列为解决线程安全的第三种方式

12.2 列子

// 卖票
public class RunMainLock {
    public static void main(String[] args) {
        Wins wins = new Wins();
        /*创建三个线程*/
        Thread win1 = new Thread(wins);
        Thread win2 = new Thread(wins);
        Thread win3 = new Thread(wins);
        /*设置线程名字*/
        win1.setName("窗口一：");
        win2.setName("窗口二：");
        win3.setName("窗口三：");
        /*开启线程*/
        win1.start();
        win2.start();
        win3.start();
    }
}

class Wins implements Runnable{
    private  int ticket = 100;
    /*定义Lock锁*/
    /*第一步：实例化ReentrantLock*/
    private ReentrantLock lock = new ReentrantLock();/* 参数为true，线程先进先出；默认为false，即cpu轮到谁就谁，看运气*/
    @Override
    public void run() {

        while (true) {
            try{
                /*第二步：加锁*/
                lock.lock();
                if (ticket > 0) {
                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread().getName() + "卖票——" + ticket);
                    ticket--;
                } else {
                    break;
                }
            }finally {
                /*第三步：解锁*/
                lock.unlock();
            }
        }
    }
}

12.3 synchronized与Lock的异同

1. 相同点：

   1. 都能解决线程的安全问题

2. 不同点

   1. Lock是显式锁（手动开启和关闭锁，别忘记关闭锁），synchronized是隐式锁，出了作用域自动释放
   2. Lock只有代码块锁，synchronized有代码块锁和方法锁
   3. 使用Lock锁，JVM将花费较少的时间来调度线程，性能更好。并且具有更好的扩展性（提供更多的子类）

3. 总结：

   优先使用顺序（建议）：
   
   Lock>同步代码块（已经进入了方法体，分配了相应资源）>同步方法（在方法体之外）

十三、线程的通信问题

13.1 初步代码

让线程执行一次之后，阻塞，把cpu资源给其他线程。

/**
 * 使用两个线程打印 1-100。线程1, 线程2 交替打印
 */
public class Test {
    public static void main(String[] args) {
        Test1 test1 = new Test1();
        Thread thread1 = new Thread(test1);
        Thread thread2 = new Thread(test1);
        thread1.setName("线程一：");
        thread2.setName("线程二：");
        thread1.start();
        thread2.start();
    }
}
class Test1 implements Runnable{
    private int j = 1;
    @Override
    public  void run() {
        while (true) {
            synchronized (this) {// this的使用，指向调用该方法的对象的引用test1。在该处做为锁
                if (j <= 100) {
                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread().getName()+":打印"+j);
                    j++;
                    try {
              /*第一个线程打印一个数字之后，调用wait方法便阻塞了，同时释放了锁。
              第二个线程获得锁之后，打印一个数字之后，调用wait方法也阻塞了，同时释放了锁。
              此时这两个线程都被阻塞了，因此只打印了2次
              */
                        wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }

                }else{
                    break;
                }
            }
        }
    }
}

结果：

总结wait方法：

从执行结果我们不难推断出，wait方法至少有2个作用或者功能：

1. 阻塞当前线程
2. 释放锁【不释放锁的的话，第二个线程怎么进得来】

13.2 最终代码

/**
 * 使用两个线程打印 1-100。线程1, 线程2 交替打印
 */
public class Test {
    public static void main(String[] args) {
        Test1 test1 = new Test1();
        Thread thread1 = new Thread(test1);
        Thread thread2 = new Thread(test1);
        thread1.setName("线程一");
        thread2.setName("线程二");
        thread1.start();
        thread2.start();
    }
}
class Test1 implements Runnable{
    private int j = 1;
    @Override
    public  void run() {
        while (true) {
            synchronized (this) {
                /*程序开始：假设此时第一个线程拿着锁（this）进来了，第二个线程在外面等待着。
                第一个线程执行notify()方法没有什么影响，接着进入判断，打印了“线程一:打印1”后，调用wait()方法后阻塞，
                同时释放锁（this）【这步操作很重要】。此时第二个线程拿到了锁进来了，执行notify()方法，唤醒第一个线程
                【注意此时此刻，第二个线程还拿着锁，所以第一个线程被唤醒之后，也只能在外面等待】，接着第二个线程进入判断,
                打印“线程二：打印2”后，调用wait()方法后阻塞，同时释放锁。此时此刻第一个线程又拿到了锁，接着执行。
                【后面就是重复的了，第一个线程和第二个线程之间，不停的被阻塞、又不停的被唤醒，直到循环结束】
                *
                * */
                //第二步
                notify();
                if (j <= 100) {
                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread().getName()+":打印"+j);
                    j++;
                    try {
              /*第一个线程打印一个数字之后，调用wait方法便阻塞了，同时释放了锁。
              第二个线程获得锁之后，打印一个数字之后，调用wait方法也阻塞了，同时释放了锁。
              此时这两个线程都被阻塞了，因此只打印了2次
              */
                        //第一步
                        wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }else{
                    break;
                }
            }
        }
    }
}

结果：实现了交替打印

总结 notify()：

1. 唤醒一个线程【因为还有notifyAll()方法】

13.3 线程通信总结

线程通信涉及到的三个方法：

1. wait()：一旦执行此方法，当前线程就进入阻塞状态，并释放同步监视器
2. notify():一旦执行此方法，就会唤醒被wait方法的一个线程，如果有多个线程被wait，就唤醒优先级高的那个，如果优先级相同，就随机唤醒一个
3. notifyAll():一旦执行此方法，就会唤醒被wait方法的所有线程，

注意：

1. wait()，notify()，notifyAll()三个方法必须使用在同步代码块或同步方法中。【lock中不能使用】

2. wait()，notify()，notifyAll()三个方法的调用者必须是同步代码块或同步方法中的同步监视器。

   否则会出现IllegalMonitorStateException异常

3. wait()，notify()，notifyAll()三个方法是定义在java.lang.object类中。

   为什么是定义在Object类中？

   • 因为你要保证“2.wait()，notify()，notifyAll()三个方法的调用者必须是同步代码块或同步方法中的同步监视器。”
   • 我们说过总结过任何一个对象都可以充当同步监视器，所有的对象都可以调用这三个方法，那么这三个方法必然是是定义在object类中的，因为所有的类都继承Object类。【注意Java中是单继承，但是可以多层继承。即如：Object---Parent---Child】