05 Java线程同步

多个线程操作同一个资源

并发

定义： 同一个对象被多个线程同时操作

处理多线程问题时，多个线程访问同一个对象，并且某些线程还想修改这个对象。这时候我们就需要线程同步。线程同步其实就是一种等待机制，多个需要同时访问此对象的线程进入这个对象的等待池形成队列，等待前面线程使用完毕，下一个线程再使用。

由于同一进程的多个线程共享同一块存储空间，在带来方便的同时，也带来访问冲突问题，为了保证数据在方法中被访问时的正确性，在访问时加入锁机制（synchronized），当一个线程获得对象的排它锁，独占资源，其他线程必须等待，使用后释放锁即可。存在以下问题：

• 一个线程持有锁会导致其他所有需要此锁的线程挂起
• 在多线程竞争下，加锁，释放锁会导致比较多的上下文切换和调度延时，引起性能问题
• 如果一个优先级高的线程等待一个优先级低的线程释放锁会导致优先级倒置，引起性能问题

同步方法

由于我们可以通过private关键字来保证数据对象只能被方法访问，所以我们只需要针对方法提出一套机制，这套机制就是synchronized关键字，它包括两种方法：

synchronized方法和synchronized块

同步方法：public synchronized void method（int args）{}

synchronized方法控制对“对象”的访问，每个对象对应一把锁，每个synchronized方法都必须获得调用该方法的对象的锁才可以执行，否则线程会被阻塞，方法一旦执行，就独占该锁，直到该方法返回才释放锁，后面被阻塞的线程才能获得这个锁，继续执行。

缺陷：若将一个大的方法声明为synchronized将会影响效率

同步块

• 同步块：synchronized(Obj){ }

• Obj称之为同步监听器

  • Obj可以是任何对象，但是推荐使用共享资源作为同步监听器
  • 同步方法中无需指定同步监视器，因为同步方法的同步监视器就是this，就是这个对象本身，或者是class

• 同步监视器的执行过程

  1. 第一个线程访问，锁定同步监视器，执行其中的代码。
  2. 第二个线程访问，发现同步监视器被锁定，无法访问。
  3. 第一个线程访问完毕，解锁同步监视器。
  4. 第二个线程访问，发现同步监视器没有锁，然后锁定并访问。

死锁

多个线程各自占有一些共享资源，并且互相等待其他线程占有的资源才能运行，而导致两个或者多个线程都在等待对方释放资源，都停止执行的情形。某一个同步块同时拥有“两个以上对象的锁”时，就可能会发生“死锁”的问题。

死锁避免的方法

产生死锁的四个必要条件;

1. 互斥条件：一个资源每次只能被一个进程使用
2. 请求与保持条件：一个进程因请求资源而阻塞时，对已获得的资源保持不放。
3. 不剥夺条件：进程已获得的资源，在未使用完之前，不能强行剥夺。
4. 循环等待条件：若干进程之间形成一种头尾相接的循环等待资源关系。

上面列出了死锁的四个必要条件，我们只要想办法破其中的任意一个或者多个条件就可以避免死锁的发生

Lock（锁）

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

import java.util.concurrent.locks.ReentrantLock;

//测试Lock锁
public class TestLock {
    public static void main(String[] args) {
        Testlock2 testlock2 = new Testlock2();
        new Thread(testlock2,"xia").start();
        new Thread(testlock2,"jie").start();
        new Thread(testlock2,"jia").start();
    }
}

class Testlock2 implements Runnable {

    int ticketNums = 1000;
    private final ReentrantLock lock = new ReentrantLock();
    
    @Override
    public void run() {
        while (true){
            try{
                lock.lock();
                if (ticketNums > 0){
                    try {
                        Thread.sleep(10);
                        System.out.println(Thread.currentThread().getName() + "购买了票，还剩" + ticketNums--);
                    }catch (InterruptedException e){
                        e.printStackTrace();
                    }

                }else break;
            } finally {
                lock.unlock();
            }
        }
    }
}

class A{
    private final ReentrantLock lock = new ReentrantLock();
    public void m(){
        lock.lock();
        try{
            //保证线程安全的代码
        }finally{
            lock.unlock();
            //如果同步代码有异常，要将unlock（）写入到finally中
        }
    }
}

解决方法一：

并发协作模型“生产者/消费者模式”—>管程法

• 生产者：负责生产数据的模块（可能是方法、对象、线程和进程）
• 消费者：负责处理数据的模块（可能是方法、对象、线程和进程）
• 缓冲区：消费者不能直接使用生产者的数据，它们之间有个“缓冲区”

生产者将生产好的数据放入缓冲区，消费者从缓冲区拿出数据

测试代码：生产者消费者模型—> 利用缓冲区解决：管程法

public class testPC {
    public static void main(String[] args) {
        SynContainer container = new SynContainer();

        new Producer(container).start();
        new Consumer(container).start();
    }
}

//生产者
class Producer extends Thread{
    SynContainer container;
    public Producer (SynContainer container){
        this.container = container;
    }

    //生产

    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            container.push(new Chicken(i));
            System.out.println("生产力" + i + "只鸡");
        }
    }
}

//消费者
class Consumer extends Thread{
    SynContainer container;

    public Consumer(SynContainer container){
        this.container = container;
    }


    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.println("消费了" + container.pop().id + "只鸡。");
        }
    }
}

//产品
class Chicken{
    int id; //产品编号

    public Chicken(int id) {
        this.id = id;
    }
}

//缓冲区
class SynContainer {
    //需要一个容器
    Chicken[] chickens = new Chicken[10];
    //容器计数器
    int count = 0;
    //生产者放入产品
    public synchronized void push(Chicken chicken){
        //如果容器满了，就需要消费者消费
        if(count == chickens.length){
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

        //如果没有满，我们就需要生产到缓冲区
        chickens[count] = chicken;
        count++;

        //可以通知消费者消费
        this.notifyAll();
    }
    //消费者消费
    public synchronized Chicken pop(){
        //判断能否消费
        if (count == 0){
            //等待生产者生产，消费者等待
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

        //如果可以消费
        count--;
        Chicken chicken = chickens[count];

        //吃完了，通知生产者生产
        this.notifyAll();

        return chicken;
    }


}

解决方法二：

• 并发协作模型”生产者/消费者模式“ —> 信号灯法

public class TestPC2 {
   public static void main(String[] args) {
       TV tv = new TV();
       new Player(tv).start();
       new Watcher(tv).start();
   }
}

//生产者-->演员
class Player extends Thread{
   TV tv;
   public Player(TV tv){
       this.tv = tv;
   }

   @Override
   public void run() {
       for (int i = 0; i < 20; i++) {
           if (i % 2 == 0){
               this.tv.play("正在播放密室大逃脱2...");
           }else {
               this.tv.play("广告时间...");
           }
       }
   }
}

//消费者-->观众
class Watcher extends Thread{
   TV tv;

   public Watcher(TV tv) {
       this.tv = tv;
   }

   @Override
   public void run() {
       for (int i = 0; i < 20; i++) {
           tv.watch();
       }
   }
}

//产品 -->节目
class TV{
   //演员表演，观众等待 T
   //观众观看，演员等到 F
   String voice;   //表演的节目
   boolean flag = true;

   //表演
   public synchronized void play(String voice){
       if (!flag){
           try {
               wait();
           } catch (InterruptedException e) {
               e.printStackTrace();
           }
       }
       System.out.println("演员表演了：" + voice);

       //通知观众观看
       this.notifyAll();
       this.voice = voice;
       this.flag = !this.flag;

   }

   //观看
   public synchronized void watch(){
       if(flag){
           try {
               this.wait();
           } catch (InterruptedException e) {
               e.printStackTrace();
           }
       }
       System.out.println("观众观看了：" + voice);
       //通知演员表演
       this.notifyAll();
       this.flag = !this.flag;

   }
}

synchronized与Lock的对比

• Lock是显示锁（手动开启和关闭锁，别忘记关掉）synchronized是隐式锁，出了作用域自动释放

• Lock只是代码块锁，synchronized有代码块锁和方法锁

• 使用Lock锁，JVM将会花费较少的时间来调度线程，性能更好。并且具有更好的扩展性（提供更多的子类）

• 优先使用顺序

  Lock > 同步代码块（已经进入方法体，分配相应资源） > 同步方法（在方法体外）

使用线程池

• 背景:经常创建和销毁、使用量特别大的资源，比如并发情况下的线程，对性能影响很大。

• 思路：提前创建好多个线程，放入线程池中，使用时直接获取，使用完放回池中

• 好处：

  • 提高响应速度（减少了创建新线程的时间）
  • 降低资源消耗（重复利用线程池中线程，不需要每次都创建）
  • 便于线程管理（…）
    • corePoolSize:核心池的大小
    • maximumPoolSize:最大线程数
    • keepAliveTime：线程没有任务时最多保持多长时间后会终止

• JDK 5.0起提供了线程池相关API：ExecutorService和Executors

• ExecutorService：真正的线程池接口。常见子类：ThreadPoolExecutor

  • void execute（Runnable command）：执行任务/命令，没有返回值，一般用来执行Runnable
  • <T>Future<T> submit(Callable<T> task):执行任务，有返回值，一般又来执行Callable
  • void shutdown()：关闭连接池、

Executors：工具类、线程池的工厂类，用于创建并返回不同类型的线程池

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class TestPool {
    public static void main(String[] args) {
        //1.创建服务，创建线程池
        //newFixedThreadPool 参数为：线程池大小
        ExecutorService service = Executors.newFixedThreadPool(10);

        //执行
        service.execute(new Mythread());
        service.execute(new Mythread());
        service.execute(new Mythread());
        service.execute(new Mythread());

        //2.关闭连接
        service.shutdown();
    }
}
class Mythread implements Runnable{

    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName());
    }
}