多线程：锁（死锁、Lock锁、线程池）

1、死锁

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

（1）创建相应的方法实现死锁：

//多个线程互相抱着对方需要的资源，然后形成僵持
public class DemoLock {

}

class Lipstick{

}

class Mirror{

}

class Makeup extends Thread{
    //用static保证资源只有一份
    static Lipstick lipstick=new Lipstick();
    static Mirror mirror=new Mirror();

    int choice;
    String girlName;

    Makeup(int choice,String girlName){
        this.choice=choice;
        this.girlName=girlName;
    }

    public void run(){
        makeup();
    }

    private void makeup(){//互相持有对方的锁，就是需要拿到对方的资源
        if(choice==0){
            synchronized (lipstick){//获得口红的锁
                System.out.println(this.girlName+"获得口红的锁");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                synchronized (mirror){//一秒钟后获得镜子的锁
                    System.out.println(this.getName()+"获得了镜子的锁");
                }
            }
        }else{
            synchronized (mirror){//获得镜子的锁
                System.out.println(this.girlName+"获得镜子的锁");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                synchronized (lipstick){//一秒钟后获得口红的锁
                    System.out.println(this.getName()+"获得口红的锁");
                }
            }
        }

    }

}

（2）创建测试类：

创建两个线程：

public class Test {
    public static void main(String[] args) {
        Makeup makeup1=new Makeup(0,"灰姑娘");
        Makeup makeup2=new Makeup(1,"白雪公主");

        makeup1.start();
        makeup2.start();
    }
}

（3）测试：

灰姑娘获得口红的锁
白雪公主获得镜子的锁

可以看到，以上两个线程，在获得各自的资源之后，再去获得对方资源的时候，发生了死锁

（4）避免死锁：

private void makeup(){//互相持有对方的锁，就是需要拿到对方的资源
        if(choice==0){
            synchronized (lipstick){//获得口红的锁
                System.out.println(this.girlName+"获得口红的锁");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            synchronized (mirror){//一秒钟后获得镜子的锁
                System.out.println(this.getName()+"获得了镜子的锁");
            }
        }else{
            synchronized (mirror){//获得镜子的锁
                System.out.println(this.girlName+"获得镜子的锁");
                try {
                    Thread.sleep(2000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            } synchronized (lipstick){//一秒钟后获得口红的锁
                System.out.println(this.getName()+"获得口红的锁");
            }
        }

    }

不能占有两个资源

 

2、死锁的预防

（1）破坏请求和保持条件

第一种协议：

破坏请求：一次申请在运行过程中的全部资源

破坏保持：只要有一种资源没有满足进程的要求，就让该进程等待，也就是说在进程等待期间未占用任何资源。

缺点：资源浪费；会发生饥饿现象。

第二种协议：

进程只获得运行初期所需要的资源，运行过程中逐步释放已分配给自己的资源。

（2）破坏不可抢占条件

当一个已经保持了某些不可被抢占资源的进程提出新的资源请求而得不到满足时，必须释放已有资源。

（3）破坏循环等待条件

对系统中所有资源类型进行线性排序，并赋予不同的序号。每个进程按照序号递增的顺序请求资源

 

3、Lock锁

（1）在代码中加锁：

public class TestLock implements Runnable {
    static int ticketNums=10;
    private final ReentrantLock lock=new ReentrantLock();
    @Override
    public void run() {
        while (true){
            lock.lock();
            if(ticketNums>0){
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(ticketNums--);
            }else {
                break;
            }
            lock.unlock();
        }
    }
}

（2）测试：

public class Test {
    public static void main(String[] args) {
        TestLock testLock=new TestLock();
        new Thread(testLock,"zhai").start();
        new Thread(testLock,"zhang").start();
        new Thread(testLock,"liu").start();
    }
}

10
9
8
7
6
5
4
3
2
1

 

4、synchronized与Lock的对比

Lock是显式锁（手动开启和关闭锁，不能忘记解锁）synchronized是隐式锁，出了作用域自动释放

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

使用Lock锁，jvm将花费较少的时间来调度线程，性能更好。并且具有更好的扩展性

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

 

5、线程池

（1）背景

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

（2）思路

提前创建好多个线程，放入线程池中，使用时直接获取，使用完时放回池中，可以避免频繁地创建销毁、实现重复利用。类似生活中的公共交通工具。

（3）好处

提高响应速度（减少了创建新线程的时间）

降低资源消耗（重复利用线程池中的线程，不需要每次都创建）

便于线程管理（线程池的大小、最大线程数、线程没有任务时最多保持多长时间会终止）

（4）书写代码

创建一个类，实现Runnable接口：

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

创建测试类：

public class TestPool {
    public static void main(String[] args) {
        ExecutorService executorService= Executors.newFixedThreadPool(10);

        executorService.execute(new MyThread());
        executorService.execute(new MyThread());
        executorService.execute(new MyThread());
        executorService.execute(new MyThread());

        executorService.shutdown();
    }
}