12【多线程、锁机制、lock锁】

一、多线程概念

在实际应用中，多线程非常有用。例如，一个浏览器可以同时下载几幅图片，一个WEB浏览器需要同时服务来自客户端的请求，我们的电脑管家也可以一边杀毒一边清理垃圾再一边进行电脑体检等任务，这些都是多线程的应用场景。

1.1 程序的并发与并行

1.1.1 程序的并行

程序的并行指的是多个应用程序真正意义上的同时执行，CPU分配多个执行单元共同执行这些任务，效率高，但这依赖于CPU的硬件支持，需要CPU多核心的支持，单核处理器的CPU是不能并行的处理多个任务的。

1.1.2 程序的并发

程序的并发指的是多个应用程序交替执行，CPU分配给每个应用程序一些“执行时间片”用于执行该应用程序，由于CPU的处理速度极快，并且分配个每个线程的“执行时间片”极短，给人们造成视觉上的误感，让人们以为是“同时”执行，其实是交替执行。

需要注意的是：虽然是交替执行，但是程序的并发解决了多个程序之间不能“同时”执行的问题，并且程序的并发利用了CPU的空余时间，能将CPU的性能较好的发挥，另外并发不受CPU硬件的限制，实际开发中，并发往往使我们考虑的重点。

tips：程序并行执行需要依赖于CPU的硬件支持，而并发却不需要；

1.2.3 多线程并发就一定快吗？

我们知道，并发本质上其实是多条线程交替执行，线程在交替过程中需要损耗一部分性能，由于CPU分配给这些线程执行的时间片非常短，线程交替也非常频繁，因此线程交替是一个比较消耗性能的步骤；

在大部分情况下，多线程的并发能够提升我们程序的执行速度，如：

当应用程序需要同时处理多个任务时，每一个任务都需要花费大量的时间，这个时候我们可以开辟多条程序执行线路来并发的”同时”处理多个任务；
但是当任务处理时间很短，这个时候根本不需要开启多个线程来”同时”处理多个任务，因为任务处理时间非常短暂，还没等CPU切换到其他线程任务就执行完毕了，这个时候多线程反而使得程序效率低；

这就好比如我们的任务是”烧水”，我们需要烧开10壶水，每一壶水的烧开都是一个漫长的时间过程。

在单线程环境中：在水烧开的过程中，CPU只能干等着，等第一壶水烧开了后，才可以烧第二壶水，以此类推…这样效率非常慢
在多线程环境中：在水烧开的过程中，CPU去分配时间去其他的线程，让其他的线程也来烧水，这样可以让多个水壶同时烧水，效率快；

这样下来，多线程效率更高；

但是现在我们的任务如果变为了”拍蒜”，我们需要拍10个蒜，拍一瓣蒜的速度非常快；

在单线程环境中：拿起一把刀拍一个蒜，然后马上拍另一瓣蒜…拍10个蒜的时间花费8秒。
在多线程环境中：拿起一把刀拍一个蒜，然后马上换另一把刀拍一个蒜…拍10个蒜的时间花费15秒。

这样下来，单线程效率更高；

Tips：在上述案例中，不管是”烧水”还是”拍蒜”都是一个人（CPU核心）在操作多个器具（调度多个线程），如果出现了多个人来同时操作多个器具那就不属于并发的范畴了，而是属于并行；

1.2 进程与线程

1.2.1 进程

进程：是指一个内存中运行的应用程序，我们开启的应用如QQ、微信、google浏览器、idea开发工具等都是一个应用，一个应用最少具备一个进程，也有可能有多个进程，每个进程都有一个独立的内存空间，进程是系统运行程序的基本单位；

多个进程的执行可以是并行也可以是并发；

1.2.2 线程

线程：线程是进程中的一个执行单元，负责当前进程中程序的执行，是一个程序内部的一条执行路径，一个进程中至少有一个线程。一个进程中是可以有多个线程的，这个应用程序也可以称之为多线程程序；

关于进程和线程的概念我们理解即可，上图中电脑管家的“首页体检”、“病毒查杀”等功能也有可能是一个进程来完成，关于病毒查杀功能下面可能还有其他小功能，有可能是线程完成，也有可能还是一个独立的进程来完成；

二、Java中的多线程

2.1 Java线程体验

Java使用java.lang.Thread类代表线程，所有的线程对象都必须是Thread类或其子类的实例。每个线程的作用是完成一定的任务，实际上就是执行一段程序代码。

继承Thread类都将变为线程类，调用Thread类中的start()方法即开启线程；当线程开启后，将会执行Thread类中的run方法，因此我们要做的就是重写Thread中的run方法，将线程要执行的任务由我们自己定义；

2.1.1 线程初体验

定义线程类：

package com.dfbz.demo01;

/**
 * @author lscl
 * @version 1.0
 * @intro: 继承Thread类称为线程类
 */
public class MyThread extends Thread {

    public MyThread() {
    }

    /**
     * 重写父类的构造方法,传递线程名称给父类
     *
     * @param name
     */
    public MyThread(String name) {
        super(name);
    }

    /*
            重写run方法,当线程开启后,将执行run方法中的程序代码
         */
    @Override
    public void run() {
        for (int i = 0; i < 1000; i++) {
            System.out.println(getName() + "线程正在执行: " + i);
        }
    }
}

测试类：

package com.dfbz.demo01;

/**
 * @author lscl
 * @version 1.0
 * @intro:
 */
public class Demo01 {
    public static void main(String[] args) {

        MyThread thread = new MyThread("线程1");
        // 开启新的线程
        thread.start();

        for (int i = 0; i < 1000; i++) {
            System.out.println("main线程正执行： " + i);
        }
    }
}

运行结果：

运行测试代码，观察是否交替执行；如果没有，可能是因为执行任务太少，CPU分配的一点点时间片就足以将线程中的任务全部执行完毕，可以扩大循环次数；观察效果；

2.1.2 线程执行流程

首先程序运行开启main线程执行代码，执行start()方法时开启一条新的线程来执行任务，新的线程与main线程争夺CPU的执行权在交替执行；

需要注意的是：当开启一个新线程之后（start方法被调用），JVM会在栈内存中开辟一块新的内存空间，每个线程都有自己独立的栈空间，进行方法的弹栈和压栈。线程和线程之间栈内存独立，堆内存和方法区内存共享。一个线程一个栈。

2.2 线程类

2.2.1 常用方法

构造方法：

public Thread():分配一个新的线程对象。
public Thread(String name):分配一个指定名字的新的线程对象。
public Thread(Runnable target):分配一个带有指定目标新的线程对象。
public Thread(Runnable target,String name):分配一个带有指定目标新的线程对象并指定名字。

常用方法：

public String getName():获取当前线程名称。
public void start():导致此线程开始执行; Java虚拟机调用此线程的run方法。
public void run():此线程要执行的任务在此处定义代码。
public static void sleep(long millis):使当前正在执行的线程以指定的毫秒数暂停（暂时停止执行）。
public static Thread currentThread() :返回对当前正在执行的线程对象的引用。

我们前面定义线程时说到过，run方法中规定了线程执行的任务，因此我们重写run方法即可；

现在我们翻开run方法的源码看看：

public class Thread implements Runnable {
    private volatile String name;
    private int            priority;
    private Thread         threadQ;
	....

    /* What will be run. */
    private Runnable target;
 
    public Thread(Runnable target) {
        init(null, target, "Thread-" + nextThreadNum(), 0);
    }
    
    public Thread(String name) {
        init(null, null, name, 0);
    }
    ...
    
    @Override
    public void run() {
        if (target != null) {
            target.run();
        }
    }
    
    ...
}

发现执行的是Runnable对象的run方法，我们打开Runnable查看源码：

@FunctionalInterface
public interface Runnable {
    /**
     * When an object implementing interface <code>Runnable</code> is used
     * to create a thread, starting the thread causes the object's
     * <code>run</code> method to be called in that separately executing
     * thread.
     * <p>
     * The general contract of the method <code>run</code> is that it may
     * take any action whatsoever.
     *
     * @see     java.lang.Thread#run()
     */
    public abstract void run();
}

发现Runnable是个接口，并且只有一个抽象方法run()

@FunctionalInterface：标注此注解的接口只有一个抽象方法，也被称为函数式接口；

2.2.2 使用Runnable创建线程

我们前面翻阅源码得知，Thread执行的run方法实质就是执行Runnable接口中的run方法，因此我们可以传递一个Runnable对象给Thread，此Runnable封装了我们要执行的任务；

采用java.lang.Runnable也是非常常见的一种，我们只需要重写run方法即可。

步骤如下：

定义Runnable接口的实现类，并重写该接口的run()方法，该run()方法的方法体同样是该线程的线程执行体。
创建Runnable实现类的实例，并以此实例作为Thread的target来创建Thread对象，该Thread对象才是真正的线程对象。
调用线程对象的start()方法来启动线程；

定义Runnable接口：

package com.dfbz.demo02;

/**
 * @author lscl
 * @version 1.0
 * @intro: 创建一个类实现Runnable接口
 */
public class MyRunnable implements Runnable {
    @Override
    public void run() {
        for (int i = 0; i < 1000; i++) {
            // 获取当前线程对象的引用
            Thread thread = Thread.currentThread();

            System.out.println(thread.getName() + "执行： " + i);
        }
    }
}

测试类：

package com.dfbz.demo02;

/**
 * @author lscl
 * @version 1.0
 * @intro:
 */
public class Demo01 {
    public static void main(String[] args) {

        // 任务对象
        MyRunnable runnable = new MyRunnable();

        // 将任务对象传递给线程执行
        Thread thread = new Thread(runnable,"线程1");

        // 开启线程
        thread.start();

        for (int i = 0; i < 1000; i++) {
            System.out.println("main线程执行： " + i);
        }

    }
}

运行结果：

2.2.3 Thread和Runnable的区别

如果一个类继承Thread，则不适合资源共享。但是如果实现了Runable接口的话，则很容易的实现资源共享。

总结：

实现Runnable接口比继承Thread类所具有的优势：

适合多个相同的程序代码的线程去共享同一个资源。
可以避免java中的单继承的局限性。
增加程序的健壮性，实现解耦操作，代码可以被多个线程共享，代码和线程独立。
线程池只能放入实现Runable或Callable类线程，不能直接放入继承Thread的类。

扩充：在Java中，每次程序运行至少启动2个线程。一个是main线程，一个是垃圾收集线程。因为每当使用Java命令执行一个类的时候，实际上都会启动一个JVM，每一个JVM其实在就是在操作系统中启动了一个进程。

2.2.4 使用匿名内部类创建线程

1）回顾匿名内部类：

定义吃辣接口：

package com.dfbz.demo03;

/**
 * @author lscl
 * @version 1.0
 * @intro:
 */
public interface Chili {
    void chili();
}

定义人类来实现接口并且重写方法：

package com.dfbz.demo03;

/**
 * @author lscl
 * @version 1.0
 * @intro:
 */
public class Person implements Chili {
    @Override
    public void chili() {
        System.out.println("贵州煳辣椒~");
    }
}

测试类（不适用匿名内部类）：

package com.dfbz.demo03;

/**
 * @author lscl
 * @version 1.0
 * @intro:  不使用匿名内部类
 */
public class Demo01 {
    public static void main(String[] args) {

        // 需要自己创建一个真实的类(Person),然后重写抽象方法(chili)
        Chili chili=new Person();

        chili.chili();
    }
}

使用匿名内部类：

格式如下：

接口名 xxx=new 父类名或者接口名(){
    // 方法重写
    @Override
    public void method() {
        // 执行语句
    }
};

测试代码：

package com.dfbz.demo03;

/**
 * @author lscl
 * @version 1.0
 * @intro:
 */
public class Demo02 {
    public static void main(String[] args) {

        /*
        相当于:
        class Abc(匿名) implements Chili{
            @Override
            public void chili() {
                System.out.println("余干辣椒~");
            }
        }

        // 多态
        Chili abc=new Abc();

         */

        // 返回的一个Chili的子类(相当于定义了一个匿名的类,并且创建了这个匿名类的实例对象)
        Chili abc = new Chili() {         // abc是Chili接口的子类对象

            // 重写抽象方法
            @Override
            public void chili() {
                System.out.println("余干辣椒~");
            }
        };

        // 调用重写的方法
        abc.chili();
    }
}

我们发现可以直接new接口的方式重写其抽象方法，返回一个该接口的子类（该子类是匿名的）；

2）使用匿名内部类创建线程

package com.dfbz.demo03;

/**
 * @author lscl
 * @version 1.0
 * @intro:
 */
public class Demo03 {

    public static void main(String[] args) {

        /**

         相当于:
         public class Xxx implements Runnable{
            @Override public void run() {
                for (int i = 0; i < 1000; i++) {
                    System.out.println("线程1执行: " + i);
                }
            }
         }
         Runnable runnable = new Xxx();
         */
        Runnable runnable = new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < 1000; i++) {
                    System.out.println("线程1执行: " + i);
                }
            }
        };

        // 创建一个线程类,并传递Runnable的子类
        Thread thread = new Thread(runnable);

        // 开启线程
        thread.start();

        for (int i = 0; i < 1000; i++) {
            System.out.println("main线程: " + i);
        }
    }
}

2.3 线程的操作

2.3.1 线程的休眠

public static void sleep(long millis)：让当前线程睡眠指定的毫秒数

测试代码：

package com.dfbz.demo04;

/**
 * @author lscl
 * @version 1.0
 * @intro:
 */
public class Demo01 {
    public static void main(String[] args) {
        // 使用匿名内部类开启1个线程
        new Thread() {
            @Override
            public void run() {
                for (int i = 0; i < 100; i++) {
                    //当i等于50的时候让当前线程睡眠1秒钟(1000毫秒)
                    if (i == 50) {
                        try {
                            Thread.sleep(1000);
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                    System.out.println(Thread.currentThread().getName() + ": " + i);
                }
            }
        }.start();

        // 使用匿名内部类开启第2个线程
        new Thread() {
            @Override
            public void run() {
                for (int i = 0; i < 100; i++) {
                    System.out.println(Thread.currentThread().getName() + ": " + i);
                }
            }
        }.start();
    }
}

2.3.2 线程的加入

多条线程时，当指定线程调用join方法时，线程执行权交给该线程，并且当前线程必须等该线程执行完毕之后才会执行但有可能被其他线程抢去CPU执行权.

public final void join()：让线程在当前线程优先执行,直至t线程执行完毕时,再执行当前线程.
public final void join(long millis)：让线程执行millis毫秒，然后将线程执行器抛出，给其他线程争抢

示例代码：

package com.dfbz.demo04;

/**
 * @author lscl
 * @version 1.0
 * @intro:
 */
public class Demo02 {
    public static void main(String[] args) throws InterruptedException {
        //创建线程1
        Thread t1 = new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < 1000; i++) {

                    System.out.println("线程1:" + i);
                }
            }
        });

        //创建线程2
        Thread t2 = new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < 1000; i++) {
                    System.out.println("线程2:" + i);
                    if (i == 500) {
                        try {
                            //当i等于500的时候,让t1线程加入执行,直至执行完毕
//                            t1.join();
                            //当i等于500的时候,让t1线程加入执行,执行10毫秒之后交出执行权
                            t1.join(10);
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }

                }
            }
        });

        t1.start();
        t2.start();

    }
}

2.3.3 守护线程

当用户线程（非守护线程）行完毕时，守护线程也会停止执行但由于CPU运行速度太快，当用户线程执行完毕时，将信息传递给守护线程，会有点时间差，而这些时间差会导致还会执行一点守护线程；

需要注意的是：不管开启多少个线程（用户线程），守护线程总是随着第一个用户线程的停止而停止

public final void setDaemon(boolean on)：设置线程是否为守护线程

示例代码：

package com.dfbz.demo04;

/**
 * @author lscl
 * @version 1.0
 * @intro:
 */
public class Demo03 {
    public static void main(String[] args) throws InterruptedException {

        Thread t1 = new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < 2000; i++) {
                    System.out.println("守护线程1: " + i);
                }
            }
        });

        //将t1设置为守护线程
        t1.setDaemon(true);

        Thread t2 = new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < 1000; i++) {

                    System.out.println("用户线程2: " + i);
                }
            }
        });

        Thread t3 = new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < 1000; i++) {

                    System.out.println("用户线程3: " + i);
                }
            }
        });

        //开启三条线程,不管是t2还是t3线程执行完毕,守护线程都会停止
        t1.start();
        t2.start();
        t3.start();
    }
}

2.3.4 线程优先级

默认情况下，所有的线程优先级默认为5，最高为10，最低为1。优先级高的线程更容易让线程在抢到线程执行权；

通过如下方法可以设置指定线程的优先级：

public final void setPriority(int newPriority)：设置线程的优先级。

示例代码：

package com.dfbz.demo04;

/**
 * @author lscl
 * @version 1.0
 * @intro:
 */
public class Demo04 {
    public static void main(String[] args) throws InterruptedException {

        Thread t1 = new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < 1000; i++) {
                    System.out.println("线程1: " + i);
                }
            }
        });


        Thread t2 = new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < 1000; i++) {
                    System.out.println("线程2: " + i);
                }
            }
        });

        //设置优先级
        t1.setPriority(1);
        t2.setPriority(10);

        t1.start();
        t2.start();
    }
}

2.3.5 线程礼让

在多线程执行时，线程礼让，告知当前线程可以将执行权礼让给其他线程，礼让给优先级相对高一点的线程，但仅仅是一种告知，并不是强制将执行权转让给其他线程，当前线程将CPU执行权礼让出去后，也有可能下次的执行权还在原线程这里；如果想让原线程强制让出执行权，可以使用join()方法

public static void yield()：将当前线程的CPU执行权礼让出来；

示例代码：

package com.dfbz.demo04;

/**
 * @author lscl
 * @version 1.0
 * @intro:
 */
public class Demo05 {
    public static void main(String[] args) throws InterruptedException {

        Thread t1 = new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < 100; i++) {
                    System.out.println("线程1: " + i);
                }
            }
        });
        Thread t2 = new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < 100; i++) {
                    if (i == 10) {
                        //当i等于10的时候该线程礼让(礼让之后有可能下次线程执行权还被线程2抢到了)
                        Thread.yield();
                    }
                    System.out.println("线程2: " + i);
                }
            }
        });

        t1.start();
        t2.start();
    }
}

三、线程安全

3.1 线程安全问题

我们前面的操作线程与线程间都是互不干扰，各自执行，不会存在线程安全问题。当多条线程操作同一个资源时，就会产生线程安全问题；

我们来举一个案例，从广州开往南昌的票数共有100张票，售票窗口分别有“广州南站”、“广州北站”、“广州站”等。

定义卖票任务：

package com.dfbz.demo01;

/**
 * @author lscl
 * @version 1.0
 * @intro:
 */
public class Ticket implements Runnable {

    //票数
    private Integer ticket = 100;

    @Override
    public void run() {

        while (true) {

            if (ticket <= 0) {
                break;      //票卖完了
            }
            System.out.println(Thread.currentThread().getName() + "正在卖第: " + (101 - ticket) + "张票");

            ticket--;
        }
    }
}

测试类：

package com.dfbz.demo01;

/**
 * @author lscl
 * @version 1.0
 * @intro:
 */
public class Demo01 {
    public static void main(String[] args) throws InterruptedException {

        Ticket ticket = new Ticket();
        //开启三个窗口,买票
        Thread t1 = new Thread(ticket, "广州南站");
        Thread t3 = new Thread(ticket, "广州北站");
        Thread t2 = new Thread(ticket, "广州站");

        t1.start();
        t2.start();
        t3.start();
    }
}

查看运行结果：

发现程序出现了两个问题：

有的票卖了多次
卖票顺序不一致

分析：

3.2 线程同步

当我们使用多个线程访问同一资源的时候，且多个线程中对资源有写的操作，就容易出现线程安全问题。要解决上述多线程并发访问一个资源的安全性问题：也就是解决重复票与不存在票问题，Java中提供了同步机制(synchronized)来解决。

根据案例简述：窗口1线程操作的时候，窗口2和窗口3线程只能在外等着，窗口1操作结束，窗口1和窗口2和窗口3才有机会进入代码去执行。也就是说在某个线程修改共享资源的时候，其他线程不能修改该资源，等待修改完毕同步之后，才能去抢夺CPU资源，完成对应的操作，保证了数据的同步性，解决了线程不安全的现象。

Java中提供了三种方式完成同步操作：

同步代码块。
同步方法。
锁机制。

3.2.1 同步代码块

同步代码块：synchronized关键字可以用于方法中的某个区块中，表示只对这个区块的资源实行互斥访问。

语法：

synchronized(同步锁){
     需要同步操作的代码
}

同步锁：

对象的同步锁只是一个概念，可以想象为在对象上标记了一个锁；

锁对象可以是任意类型。
多个线程对象要使用同一把锁。

注意：在任何时候，最多允许一个线程拥有同步锁,谁拿到锁就进入代码块,其他的线程只能在外等着(BLOCKED)。

使用同步代码块改造代码：

package com.dfbz.demo01;

/**
 * @author lscl
 * @version 1.0
 * @intro:
 */
public class Ticket implements Runnable {
    //票数
    private Integer ticket = 100;

    //锁对象
    private Object obj = new Object();
    @Override
    public void run() {
        while (true) {
            // 加上同步代码块,把需要同步的代码放入代码块中,同步代码块中的锁对象必须保证一致！
            synchronized (obj) {
                if (ticket <= 0) {
                    break;      // 票卖完了
                }
                System.out.println(Thread.currentThread().getName() + "正在卖第: " + (101 - ticket) + "张票");
                ticket--;
            }
        }
    }
}

案例：要么输出”犯我中华者”，要么输出”虽远必诛”

package com.dfbz.demo01;

/**
 * @author lscl
 * @version 1.0
 * @intro:
 */
public class Demo02 {
    public static void main(String[] args) {
        //锁对象
        Object obj = new Object();

        new Thread() {
            @Override
            public void run() {

                for (int i = 0; i < 100; i++) {
                    //加上同步代码块锁住
                    synchronized (obj) {
                        System.out.print("犯");
                        System.out.print("我");
                        System.out.print("中");
                        System.out.print("华");
                        System.out.print("者");
                        System.out.println();
                    }
                }

            }
        }.start();

        new Thread() {
            @Override
            public void run() {

                for (int i = 0; i < 100; i++) {
                    //加上同步代码块锁住
                    synchronized (obj) {
                        System.out.print("虽");
                        System.out.print("远");
                        System.out.print("必");
                        System.out.print("诛");
                        System.out.println();
                    }
                }
            }
        }.start();
    }
}

3.2.2 同步方法

同步方法：使用synchronized修饰的方法，就叫做同步方法，保证A线程执行该方法的时候，其他线程只能在方法外等着。

注意：同步方法也是有锁对象的，对于静态方法的锁对象的当前类的字节码对象（.class），对于非静态的方法的锁对象是this；

语法：

public synchronized void method(){
   	可能会产生线程安全问题的代码
}

使用同步方法：

package com.dfbz.demo02;

/**
 * @author lscl
 * @version 1.0
 * @intro:
 */

public class Demo01 {
    public static void main(String[] args) {
        Shower s = new Shower();

        //开启线程1调用show方法
        new Thread() {
            @Override
            public void run() {
                while (true) {
                    s.show();
                }
            }
        }.start();

        //开启线程2调用show2方法
        new Thread() {
            @Override
            public void run() {
                while (true) {
                    s.show2();
                }
            }
        }.start();

    }
}

class Shower {

    //非静态同步方法的锁对象默认是this
    public synchronized void show() {

        System.out.print("犯");
        System.out.print("我");
        System.out.print("中");
        System.out.print("华");
        System.out.print("者");
        System.out.println();
    }

    public void show2() {
        //使用this锁也能够保证代码同步
        synchronized (this) {
            System.out.print("虽");
            System.out.print("远");
            System.out.print("必");
            System.out.print("诛");
            System.out.println();
        }
    }
}

3.2.3 Lock锁

java.util.concurrent.locks.Lock机制提供了比synchronized代码块和synchronized方法更广泛的锁定操作，同步代码块/同步方法具有的功能Lock都有，除此之外更强大，更体现面向对象。

Lock锁也称同步锁，加锁与释放锁方法化了，如下：

public void lock() ：加同步锁。
public void unlock()：释放同步锁。

示例代码：

package com.dfbz.demo03;

import java.util.concurrent.locks.ReentrantLock;

/**
 * @author lscl
 * @version 1.0
 * @intro:
 */
public class Demo01 {
    public static void main(String[] args) {
        //创建锁对象
        ReentrantLock lock = new ReentrantLock();

        new Thread() {
            @Override
            public void run() {

                while (true) {
                    //开启锁
                    lock.lock();
                    System.out.print("虽");
                    System.out.print("远");
                    System.out.print("必");
                    System.out.print("诛");
                    System.out.println();
                    //释放锁
                    lock.unlock();
                }
            }
        }.start();


        new Thread() {
            @Override
            public void run() {

                while (true) {
                    //开启锁
                    lock.lock();
                    System.out.print("犯");
                    System.out.print("我");
                    System.out.print("中");
                    System.out.print("华");
                    System.out.print("者");
                    System.out.println();

                    //释放锁
                    lock.unlock();
                }

            }
        }.start();
    }
}

3.2.4 线程死锁

多线程同步的时候，如果同步代码嵌套，使用相同锁，就有可能出现死锁；

分析：

示例代码：

package com.dfbz.demo04;

/**
 * @author lscl
 * @version 1.0
 * @intro:
 */
public class Demo01 {
    public static void main(String[] args) {
        String s1 = "s1";
        String s2 = "s2";
        new Thread() {
            public void run() {
                while (true) {
                    synchronized (s1) {
                        System.out.println(this.getName() + "s1");
                        synchronized (s2) {
                            System.out.println(this.getName() + "s2");
                        }
                    }
                }
            }
        }.start();
        new Thread() {
            public void run() {
                while (true) {
                    /*
					当线程0拿到s1执行s1中的打印语句时,如果线程切换到线程1
					那么线程1拿到了s2锁对象,此时就造成了线程死锁
					线程1想执行s1锁里面的代码执行不了,因为s1在线程0中还没有释放
					那么此时线程1就会切换到线程0
                    线程0也不会执行s2锁里面的代码,因为此时s2已经被线程0中的锁拿去了
                    还没有释放,因此造成了线程的死锁
                    两个都没有释放  都卡住了  线程就卡住了
                     */
                    synchronized (s2) {
                        System.out.println(this.getName() + "s2");
                        synchronized (s1) {
                            System.out.println(this.getName() + "s1");
                        }
                    }
                }
            }
        }.start();
    }
}