Java多线程

*）了解线程与进程的区别
*）掌握创建多线程的两种方式
*）了解线程的生命周期及状态转换
*）掌握线程调度
*）掌握多线程的同步

多线程是提升程序性能非常重要的一种方式，也是学习Java编程必须要掌握的技术。使用多线程可以让程序充分利用CPU的资源，提高CPU的使用效率，从而解决高并发带来的负载均衡问题，
线程概述：
计算机能够同时完成多项任务，例如：一边访问浏览器，一边使用QQ聊天，这就是多线程技术，计算机的中央处理器（Central Processing Unit ，CPU）即使是单核也可以同时运行多个任务，因为操作系统执行多个任务时就是让CPU对多个任务进行轮流交替运行。java时支持多线程的语言之一，它对多线程编程提供了内置支持，可以使程序执行多个执行片段。。
进程：Process
在学习线程之前，需要先了解什么是进程。在一个操作 系统中，每个独立的程序都可以称为一个进程，也就是“正在运行的程序”。在多任务操作系统中，表面上是支持进程并发执行，例如一边听音乐一边聊天。但是实际上进程并不是同时运行的。在计算机中，所有的应用程序都是由CPU执行的，对于CPU而言，在某个时间点只能运行一个程序，也就是说只能运行一个进程。操作系统会为每个进程分配一段有限的CPU使用时间，CPU在这段时间执行某个进程，然后在下一段时间执行另一个进程。由于CPU运行速度很快，能在极短的时间内不同的进程之间进行切换，所有给人同时执行多个程序的感觉。
例如：在现实生活中有太多同时做多件事情的例子。看起来多任务都在做，但是其本质还是在同一时间我们的大脑只做了一件事。
多线程：Thread
每个运行的程序都是一个进程，在进程中还可以有多个执行单元同时运行，之前学习的章节中代码都是依次往下执行的，没有出现两段代码交替执行，这样的程序称作为单线程程序。如果想要程序实现多段代码交替运行的效果，则需要创建多个线程，既多线程。多线程是指一个进程在执行的过程中产生的多个单线程，这些单线程程序运行时是相互独立的，它们可以并发执行。多线程看似是同时执行的其实于进程是一样的，也是由CPU轮流执行的，CPU很快，故而给人一种同时运行的感觉

Thread class（继承Thread类：重点）
Runnable接口（实现Runnable接口：重点）
Callable接口（实现Callable接口：了解）

Thread类演示：
创建线程方法一：由一个类继承Thread类然后重写run（）方法，在调用这个线程时要先创建整继承类的对象然后调用start（）方法开启线程

package TestThread;


public class Demo01 extends Thread{
    @Override
    public void run() {
        //run方法线程体
        for (int i = 0; i < 20; i++) {
            System.out.println("我在学习---"+i);
        }
    }
    //main线程。主线程
    public static void main(String[]args){
        //创建一个线程对象
        Demo01 d = new Demo01();
        //调用start方法开启线程
        d.start();


        for (int i = 0; i < 2000; i++) {
            System.out.println("我在学习多线程---"+i);
        }
    }
    //总结：注意，线程开启不一定立即执行，有CPU调度执行
}

运行结果：我们可以看到创建的线程运行结果时穿插在主线程内的
这说明了：线程开启不一定立即执行，有CPU调度执行

实现Runnable接口：
定义MyRunnable类实现Runnable接口；
实现run（）方法，编写线程体。
创建线程对象，使用start（）方法启动线程

package TestThread;


public class Demo03 implements Runnable{
    @Override
    public void run() {
        //run方法线程体
        for (int i = 0; i < 20; i++) {
            System.out.println("我在学习---"+i);
        }
    }
    //main线程。主线程
    public static void main(String[]args){
        //创建Runnable接口实现类对象
        Demo03 d = new Demo03();
        //创建线程对象，通过线程对象开启我们的线程，代理
//        Thread thread = new Thread(d);
//        thread.start();
        new Thread(d).start();

        for (int i = 0; i < 1000; i++) {
            System.out.println("我在学习多线程---"+i);
        }
    }
}

运行结果：
小结：
继承Thread类：
子类继承Thread类具备多线程能力。
启动线程：子类对象.start()
不建议使用：避免Java单继承局限性。
实现Runnable的接口：
实现Runnable接口具备多线程能力。
启动线程：new Thread(传入目标对像）.start();
推荐使用，避免单继承局限性，灵活方便，方便同一个对象被多个线程使用。
例如：

package TestThread;


public class Demo04 implements Runnable{

    //1.定义票数
    private int ticketNums =10;
    //2重写run（）方法
    @Override
    public void run() {
        //写个死循环
        while(true){
            if (ticketNums<=0){//跳出死循环的条件
                break;
            }
            //模拟延时,然后捕捉一下异常
            try {
                Thread.sleep(200);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            //Thread.currentThread().getName()返回Thread对象的名字
            System.out.println(Thread.currentThread().getName()+"-->拿到了第"+ticketNums--+"票");
        }
    }
    //3.创建主线程
    public static void main(String[]args){
        //3.1创建自定义线程对象
        Demo04 demo04 = new Demo04();
        //3.2创建Thread对象传入自定义线程对象，然后定义一个名字
        new Thread(demo04,"小张").start();
        new Thread(demo04,"小六").start();
        new Thread(demo04,"小七").start();
    }
}

运行结果：
总结一下：多个线程操控同一个资源下，线程不安全，数据紊乱。
Callable接口：
1.实现Callable接口，需要返回值类型。
2.重写call方法，需要抛出异常。
3.创建目标对象
4.创建执行服务:ExecutorService ser = Executors.new FixedThreadPool(1);
5.提交执行：Future< Boolean> result1 = ser.submit(t1);
6.获取结果：Boolean r1 = resuit1.get（）；
7.关闭服务：ser.shutdownNow();
代码演示：

package TestThread;

import org.apache.commons.io.FileUtils;

import java.io.File;
import java.io.IOException;
import java.net.URL;
import java.util.concurrent.*;


public class Demo05 implements Callable {
    private String url;
    private String name;

    public Demo05(String url, String name){
        this.url = url;
        this.name = name;
    }

    @Override
    public Boolean call() {
        WebDownloader2 wd = new WebDownloader2();
        wd.downloader(url,name);
        System.out.println("下载了文件名为："+name);
        return true;
    }
    //主路经
    public static void main(String[]args) throws ExecutionException, InterruptedException {
        Demo05 t1 =new Demo05("https://upload-images.jianshu.io/upload_images/25016246-59a89b9ed48cf48a.png","d:\aaa\1.png");
        Demo05 t2 =new Demo05("https://upload-images.jianshu.io/upload_images/25016246-6e85ab67995519c7.png","d:\aaa\2.png");
        Demo05 t3 =new Demo05("https://upload-images.jianshu.io/upload_images/25016246-59a89b9ed48cf48a.png","d:\aaa\3.png");

        //创建执行服务:
        ExecutorService ser = Executors.newFixedThreadPool(3);
        //提交执行：
        Future< Boolean> r1 = ser.submit(t1);
        Future< Boolean> r2 = ser.submit(t2);
        Future< Boolean> r3 = ser.submit(t3);
        //获取结果：
        Boolean rs1 = r1.get();
        Boolean rs2 = r2.get();
        Boolean rs3 = r3.get();
        System.out.println(rs1);
        System.out.println(rs2);
        System.out.println(rs3);
        //关闭服务：
        ser.shutdownNow();
    }
}
//下载器
class WebDownloader2{
    //下载方法
    public void downloader(String url,String name){
        try {
            FileUtils.copyURLToFile(new URL(url),new File(name));
        } catch (IOException e) {
            e.printStackTrace();
            System.out.println("IO异常，downloader方法出现问题");
        }
    }
}

运行结果：
Lambda表达式：
希腊字母表中的第十一个字母，英文名称：Lambda。
避免匿名类定义过多。
其实本质属于函数式编程概念。
（params)->expression[表达式]
(params)->statement[语句]
(params)->{statements}
.)理解Functional Interface（函数式接口）是学习Java8 Lambda表达式的关键所在。
函数式接口的定义：
任何接口只包含一个抽象方法，那么这个接口就式函数式接口。
对于函数式接口，我们可以创建Lambda表达式创建对象。
例如Runnable接口就是函数式接口：
public Interface Runnable{
public abstract void run();
}

package TestThread;


public class TestLambda {
//    //3.静态内部类
//    static class Like2 implements Ilike{
//        @Override
//        public void lambda() {
//            System.out.println("i like lambda2");
//        }
//    }
    public static void main(String[]args){
//        Ilike ilike= new Like();
//        ilike.lambda();
//
//
//        ilike = new Like2();
//        ilike.lambda();
//
//        //4.局部内部类
//        class Like3 implements Ilike{
//            @Override
//            public void lambda() {
//                System.out.println("i like lambda3");
//            }
//        }
//        ilike = new Like3();
//        ilike.lambda();
//
//
//        //5.匿名内部类
//        ilike = new Ilike() {
//            @Override
//            public void lambda() {
//                System.out.println("i like lambda4");
//            }
//        };
//        ilike.lambda();
//


        //6.用lambda简化
//        ilike=()->{
//            System.out.println("i like lambda5");
//        };
        Ilike ilike = ()->
            System.out.println("i like lambda5");
        
        ilike.lambda();
    }
}
//1.定义一个函数式接口
interface Ilike{
    void lambda();
}
//2.现实类
class Like implements Ilike{
    @Override
    public void lambda() {
        System.out.println("i like lambda");
    }
}

线程方法：

代码演示：
线程停止：
线程终止练习

• 注意：
• 尽量不要用终止方法去终止线程。
• 设置一个标识位用来终止线程
• 利用次数，不建议死循环
• 最好还是线程自然执行完终止

public class Demo07 implements Runnable{
    //1.设置一个标识位
    private boolean flag = true;
    @Override
    public void run() {
        int i = 0;
        while(flag){
            System.out.println("run-----Thread"+i++);
        }
    }

    //2.设置一个公开方法停止线程，改变标识位
    public void stop(){
        this.flag= false;
    }
    public static void main(String[]args){
        Demo07 d = new Demo07();
        new Thread(d).start();

        for (int i = 0; i < 1000; i++) {
            System.out.println("main"+i);
            if (i==900){
                //调用自己写的停止方法，改变标识位停止线程
                d.stop();
                System.out.println("线程该结束了");
            }
        }
    }
}

线程休眠:
.）sleep（时间）指定当前线程阻塞的毫秒数。
.）sleep存在异常InterruptedException。
.）sleep时间到达后线程进入就绪状态。
.）sleep可以模拟网络延时，倒计时等。
.)每个对象都有一个锁，sleep不会释放锁。
模拟网络延时：

package TestThread;


public class Demo08 implements Runnable{
    //1.定义票数
    private int ticketNums =10;
    //2重写run（）方法
    @Override
    public void run() {
        //写个死循环
        while(true){
            if (ticketNums<=0){//跳出死循环的条件
                break;
            }
            //模拟延时,然后捕捉一下异常
            try {
                Thread.sleep(200);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            //Thread.currentThread().getName()返回Thread对象的名字
            System.out.println(Thread.currentThread().getName()+"-->拿到了第"+ticketNums--+"票");
        }
    }
    //3.创建主线程
    public static void main(String[]args){
        //3.1创建自定义线程对象
        Demo07 demo07 = new Demo07();
        //3.2创建Thread对象传入自定义线程对象，然后定义一个名字
        new Thread(demo07,"小张").start();
        new Thread(demo07,"小六").start();
        new Thread(demo07,"小七").start();
    }
}

模拟倒计时：

package TestThread;


public class Demo09 {
    public static void main(String[]args){
        try {
            tenDown();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    public static void tenDown() throws InterruptedException {
        int num = 10;
        while(true){
            Thread.sleep(1000);
            System.out.println(num--);
            if (num<=0){
                break;
            }
        }
    }
}

线程礼让：
线程礼让，让当前正在执行的线程暂停，但不阻塞。
将线程从运行状态转为就绪zhuangt。
让CPU重新调度，礼让比一定成功，主要看CPU心情。

package TestThread;


public class Demo10 {
    public static void main(String[] args) {
        MyYield myYield = new MyYield();

        new Thread(myYield,"a").start();
        new Thread(myYield,"b").start();
    }
}
class MyYield implements Runnable{
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName()+"线程开始执行");
        Thread.yield();
        System.out.println(Thread.currentThread().getName()+"线程停止执行");
    }
}

礼让成功：
礼让不成功：

线程强制执行：
join合并线程，待此线程执行完毕后，再执行其他线程，其他线程阻塞。
可以想象为插队。

package TestThread;


public class Demo11 implements Runnable{
    @Override
    public void run() {
        for (int i = 0; i < 1000; i++) {
            System.out.println("线程VIP来了"+i);
        }
    }

    public static void main(String[] args) throws InterruptedException {
        //启动我们的线程
        Demo11 d = new Demo11();
        Thread t = new Thread(d);
        t.start();

        //主线程
        for (int i = 0; i < 500; i++) {
            if (i==20){
                t.join();
            }
            System.out.println("main"+i);
        }
    }
}

线程状态观测：
Thread.State
线程状态：线程可以处于以下状态之一：
.）NEW：尚未启动的线程处于此状态。
.）RUNNABLE：在Java虚拟机中执行的线程为此状态。
.）BLOCKED：被阻塞等待监视器锁定的线程为此状态。
.）WAITING：正在等待另一个线程执行特定动作的线程为此状态。
.）TIMED_WAITING:正在等待另一个线程执行动作到达指定等待时间的线程为此状态。
.）TERMINATED：已退出的线程处于此状态。
一个线程可以在指定时间点处于一个状态，这些状态不是反应任何操作系统线程状态的虚拟机。

package TestThread;


public class Demo12 {
    public static void main(String[]args) throws InterruptedException {
        Thread thread = new Thread(()->{
            for (int i = 0; i < 5; i++) {
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            System.out.println("+++++");
        });


        //观测状态
        Thread.State state = thread.getState();
        System.out.println(state);

        //观察启动后
        thread.start();
        state = thread.getState();
        System.out.println(state);

        while(state!= Thread.State.TERMINATED){//只有线程步终止就一直为输出状态
            Thread.sleep(1000);
            state = thread.getState();//更新线程状态
            System.out.println(state);//输出线程状态

        }
    }
}

运行结果：

注意：已经结束的线程不能二次调用。
线程优先级：
Java提供了一个线程调度器来监控程序中启动后进入就绪状态的所有线程，线程调度器按照优先级来决定调用那个线程来执行。
线程优先级用数字表示1~10：
Thread.MIN_PRIORITY = 1;
Thread.MAX_PRIORITY = 10;
Thread.NORM_PRIORITY = 5;
使用以下方法改变或获取优先级：
getPriority（）.setPriority（int XXX）
优先级高的不一定会先跑，只不过比普通线程多了一个机会。
优先级的设定建议设置在start（）前。
优先级低只意味着获得调度的概率低，并不意味着不会调用，主要看CPU。

package TestThread.Test2;


public class Demo01 {
    public static void main(String[]args){
        //主线程默认优先级
        System.out.println(Thread.currentThread().getName()+"-->"+Thread.currentThread().getPriority());
        Mypriority m = new Mypriority();

        Thread t1 = new Thread(m);
        Thread t2 = new Thread(m);
        Thread t3 = new Thread(m);
        Thread t4 = new Thread(m);
        Thread t5 = new Thread(m);

        //先设置优先级，再启动
        t1.start();

        t2.setPriority(1);
        t2.start();

        t3.setPriority(4);
        t3.start();

        t4.setPriority(Thread.MAX_PRIORITY);//MAX_PRIORITY=10
        t4.start();
        

    }
}
class Mypriority implements Runnable{

    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName()+"-->"+Thread.currentThread().getPriority());
    }
}

运行结果：
守护（daemon）线程：
线程分为用户线程和守护线程。
虚拟机必须确保用户线程执行完毕。
虚拟机不用等待守护线程执行完毕。
如，后台记录操作日志，垃圾回收，监控内存等。
守护线程会在用户线程结束后结束。

package TestThread.Test2;


public class Demo02 {
    public static void main(String[]args){
        God god = new God();
        You you = new You();

        Thread thread = new Thread(god);
        thread.setDaemon(true);//默认为false表示式用户线程，正常线程都是用户线程

        thread.start();//守护线程启动

        new Thread(you).start();//用户线程启动。凡人线程结束守护线程也会结束
    }
}

//老天爷
class God implements Runnable{
    @Override
    public void run() {
        while(true){
            System.out.println("老天爷，保佑着我们！");
        }
    }
}


//凡人
class You implements Runnable{
    @Override
    public void run() {
        for (int i = 0; i < 36500; i++) {
            System.out.println("又是开心的一天结束了");
        }
        System.out.println("=========goodbye world!==========");
    }
}

多个线程操作同一个资源：并发。
如：火车票购票，多台ATM机取钱等
现实生活中经常有这种例子：同一个资源，多个人都想去使用，就好比食堂吃饭不可能一窝蜂冲上去吧，有可能食堂变擂台谁都吃不成，最好的方法就是大家排队一个一个来。
在处理多线程问题时，多个线程同时访问同一个对象，并且某些线程还想修改这个对象。这时候我们就需要线程同步，线程同步其实就是一种等待机制，多个需要同时访问此对象的线程进入这个《对象的等待池》形成队列。
等待前面线程使用完毕，下一个线程再使用。
由于同一个进程的多个线程共享一块存储空间，在带来方便的同时也带来了访问冲突问题，为了保证数据在在被方法访问时的正确性，在访问时加入《锁机制：synchronized》，当一个线程获得一个对象时，会使用强人锁男，独占资源，后面的线程只能先往后邵邵，排队去，线程使用完对象就会释放对象的锁即可。
会出现一以下问题：
.）一个线程持有所会导致其他所需要此锁的线程挂起。
.）多线程竞争下加锁，释放锁，会导致比较多的上下文切换和调度延时，引起性能问题。
.）如果一个优先级高的线程等待一个优先级低的线程释放锁，会导致优先级倒置，出现性能问题。
同步方法：
由于我们通过private关键字来保障数据只能被方法访问，所以我们只需要针对方法提出一套机制，这套机制就是synchronized关键字，他包括了两种用法synchronized方法和synchronized块。
同步方法：public synchronized void method(int args){}
synchronized方法控制“对象”的访问，每个对象对应一把锁，每个synchronized方法都必须获得调用该方法的对象的锁才能执行，否则线程会阻塞，方法一旦执行就独占锁，直到该方法返回释放锁，后面被阻塞的线程才能获得这个锁，继续执行。
缺陷：若将一个大方法声明为synchronized将会影响效率。
代码演示：

package TestThread.Test2;



public class Demo03 {
    public static void main(String[]args){
        BuyTicket bt = new BuyTicket();

        new Thread(bt,"小赵").start();
        new Thread(bt,"小钱").start();
        new Thread(bt,"小孙").start();
    }
}
class BuyTicket implements Runnable{
    //票
    private int ticketNums = 10;

    //循环标识位
    boolean flag = true;
    @Override
    public void run() {
        //买票
        while(flag){
            try {
                buy();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }


    //购票方法
    //加上synchronized同步方法
    private synchronized void buy() throws InterruptedException {
        //判断是否有票
        if (ticketNums<=0){
            flag= false;
            return;
        }
        //模拟延时
        Thread.sleep(100);
        //买票
        System.out.println(Thread.currentThread().getName()+"拿到了："+ticketNums--);
    }
}

同步块：
synchronized（obj）{ }
obj称为同步监视器
obj可以是任何对象，但是推荐使用共享资源作为同步监视器。
同步方法中无需指定同步监视器，因为同步方法的同步监视器就是this，就是这个对象本身。
同步监视器的执行过程：
第一个线程访问，锁定同步监视器，执行其中代码。
第二线程访问，发现同步监视器锁定，无法访问。
第一线程访问完毕，解锁同步监视器。
第二线程访问，发现同步监视器解锁，访问并上锁。
代码演示：

package TestThread.Test2;


public class Demo04 {
    public static void main(String[]args){
        //账户
        Account account = new Account(1000,"结婚基金");

        //银行取钱
        Drawing you = new Drawing(account,50,"你");
        Drawing youWife = new Drawing(account,100,"你老婆");

        you.start();
        youWife.start();

    }
}

//账户
class Account{
    int money;//余额
    String name;//卡名

    public Account(int money, String name) {
        this.money = money;
        this.name = name;
    }
}

//银行：模拟取款
class Drawing extends Thread{
    Account account;//账户
    int drawingMoney;//取了多少钱
    int nowMoney;//现在手里有多少钱



    public Drawing(Account account, int drawingMoney, String name){
        super(name);
        this.account = account;
        this.drawingMoney = drawingMoney;
        this.nowMoney = nowMoney;

    }


    @Override
    public  void run() {
        synchronized(account){
            //判断有没有钱
            if (account.money-drawingMoney<0){
                System.out.println(Thread.currentThread().getName()+"余额不够！");
                return;
            }
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            //当前卡内余额 = 之前余额-取出的钱
            account.money = account.money-drawingMoney;

            //手里的钱
            nowMoney = nowMoney+drawingMoney;

            System.out.println(account.name+"账户余额为："+account.money);
            //getName ==Thread.currentThread().getName()
            System.out.println(getName()+"手里的钱："+drawingMoney);
        }
    }
}

注意锁是锁住的要改变资源的类对象，就好比去银行取钱你得把账户锁住别出问题，你把银行门锁住没叼用还可以手机，ATM机取钱进行账户的改动。
死锁：
多个线程各自占有一些共享资源，并且互相等待其他线程占用的资源才能运行，而导致两个或者多个线程都在等待对方释放资源，都停止执行的情形。某一个同步块拥有《两个以上的对象锁》时，就会发生《死锁》的问题
代码演示：

package TestThread.Test2;


public class Demo07 {
    public static void main(String[]args){
        Makeup m1 = new Makeup(0,"灰姑娘");
        Makeup m2 = new Makeup(1,"毒皇后");

        m1.start();
        m2.start();
    }
}
//口红
class Lipstick{

}
//镜子
class Mirror{

}
//化妆类
class Makeup extends Thread{
    //需要的资源只有一份，用static来保证
    static Lipstick lipstick = new Lipstick();
    static Mirror mirror = new Mirror();

    int choice;//选择
    String girlName;//使用化妆品的人

    public Makeup(int choice,String girlName){
        this.choice = choice;
        this.girlName = girlName;
    }
    @Override
    public void run() {

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

运行结果：抱锁抱死了
更改后：

运行结果：
总结：
避免死锁的方法：
产生死锁的四个条件：
互斥条件：一个资源每次只能被一个进程使用。
请求与保持条件：一个进程因请求资源而阻塞时，已经持有的资源保持不放。
不剥夺条件：进程以获得的资源，未使用完前，不能强行剥夺。
循环等待条件：若干个进程之间形成头尾相接的循环等待资源关系。
上列的四个条件，只有破除一个或者多个就可以避免死锁问题。
Lock锁：
从JDK5.0开始，Java提供了更强大的线程同步机制。通过显示定义同步锁实对象现同步，同步锁使用Lock对象充当。
java.util。concurrent.locks.Lock接口是控制多个线程对共享资源访问的工具。锁提供了对共享资源的单独访问，每次只能有一个线程对Lock对象加锁。线程在访问共享资源之前应先获得Lock对象。
ReentrantLock类实现了Lock，它拥有synchronized相同的并发性和内存语义，在实现线程安全控制中，比较常见的是ReentrantLock，可以显示的加锁释放锁。
代码公式：

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

代码演示：

package TestThread.Test2;

import java.util.concurrent.locks.ReentrantLock;


public class Demo08 {
    public static void main(String[]args){
        TestLock testLock = new TestLock();
        new Thread(testLock,"小赵").start();
        new Thread(testLock,"老钱").start();
        new Thread(testLock,"中孙").start();
    }
}
class TestLock implements Runnable{
    int ticketNums = 10;

    //定义lock锁
    private final ReentrantLock lock = new ReentrantLock();
    @Override
    public void run() {
        while(true){
            lock.lock();//上锁
            try {

                if (ticketNums>0){
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(ticketNums--);
                }else{
                    break;
                }

            }finally{
                //解锁
                lock.unlock();
            }
        }
    }
}

synchronized和Lock的对比：
.）Lock是显示的锁（手动开启和关闭锁，别忘了关锁）synchronized是隐式的锁，出了作用域自动释放。
.）Lock是只有代码块锁，synchronized有代码块锁和方法锁。
.） 使用Lock锁，JVM将花费较少的时间来调度线程，性能更好。并具有更好的扩展性，（有较多的子类）
.）优先顺序：
Lock>同步代码块（已经进入方法体，分配了相应的资源）>同步方法（在方法体之外）。

线程通信：
应用场景：生产者和消费者问题
.）假设仓库只能存放一件产品，生产者将生产的产品方如仓库，消费者将仓库中的产品消费取走。
.）如果仓库没有产品，生产者将产品生产放入仓库。否则停止生产，直到仓库内的产品被消费者消费取走为止。
.）如果仓库有产品，消费者消费取走产品，否则消费者停止消费，直到仓库放入产品为止。
线程通信：-分析：
这是一个线程同步的问题 ，生产者和消费者共享一个资源，并且生产者和消费者之间相互依赖，互为条件：
.）对于生产者，没有生产产品之前，要通知消费者等待，而生产了产品，又需要马上通知宪法者消费。
.）对于消费者，消费之后，要通知生产者已经结束消费，需要生产新的产品以供消费。
.）生产者消费者问题中，仅有synchronized是不够的
synchronized可以阻止并发更改同一个共享资源，实现不了同步。
synchronized不能用来实现不同线程之间的信息传递（通信）。
.）Java提供了几个方法解决线程之间的通信问题：

注意：均是Object类的方法，都只能在同步方法或同步代码块中使用，否则会抛出lllegalMonitorStateException
解决方式1：
并发协作模型“生产者/消费者模式”–>管程法
.）生产者：负责生产数据的模块（可能是方法，对象，线程，进程）
.）消费者：负责处理数据的模块（可能是方法，对象，线程，进程）
.）缓冲区：消费者不能之间使用生产的数据，它们之间有个“缓冲区”
生产者将生产好的数据放入缓冲区，消费者从缓冲区拿走数据。

package TestThread.Test2;


public class Deno09 {
    public static void main(String[]args){
        SynContainer container = new SynContainer();
        new Productor(container).start();
        new Consumer(container).start();
    }
}
//生产者
class Productor extends Thread{
    SynContainer container;
    public Productor(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.notify();
    }


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

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

        //吃完了，通知生产者生产
        this.notify();
        return chicken;
    }
}

解决方法2：
并发协作模型：“生产者/消费者模式”–>信号灯法

package TestThread.Test2;


public class Demo10 {
    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("正在播放《战狼》");
            }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.watcher();
        }
    }
}

//产品--节目
class Tv{
    //演员表演，观众等待
    //关众观看，演员等待
    String voice;//表演的节目
    boolean flag = true;//标识位

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

        this.flag = !this.flag;
    }


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

使用线程池：
.）背景：经常创建和销毁，使用量特别大的资源，比如并发情况下的线程，对性能影响很大。
.）思路：提前创建好多个线程，放入线程池中，使用时之间获取，使用完放回池中。可以避免频繁创建销毁，实现反复利用。类似生活中的公共交通。
.）好处：
1.提高响应速度（减少了创建新线程的时间）
2.降低资源消耗（重复利用线程池中线程，不需要每次都创建）
3.便于管理
corePoolSize：核心池的大小
maximumPoolSize：最大线程数
keepAliveTime：线程没有任务时最多保持多长时间后终止。
.）JDK5.0起提供了线程池相关的API：ExecutorService和Executors
.）ExecutorService：真正的线程池接口。常见的子类ThreadPoolExecutor
void execute（Runnable command）：执行任务/命令，没有返回值，一般用来执行Runnable
< T>Future< T>submit(Callable< T> task):执行任务有返回值，一般又来执行Callable
void shutdown（）：关闭连接池
Executors：工具类，线程池的工厂类，用于创建并返回不同类型的线程池。

package TestThread.Test2;

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


public class Demo11 {
    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());
        
    }
}