# Java多线程

参考视频:

BV1V4411p7EF

并发相关概念已经学过，可以直接参考操作系统相关书籍，这里不再记录。

CSDN:https://blog.csdn.net/INFINITE_WAR/article/details/122547019

# 1.线程创建

父类：Thread (java.lang.Thread) 接口：Runnable、Callable

# 1.1 创建Thread

package Multics;

public class TestThread extends Thread{
    @Override
    public void run() {
        //run方法线程体
        for(int i=0;i<20;i++){
            System.out.println("吃饭");
        }
    }

    public static void main(String[] args) {
        //主线程

        //创建一个线程对象
        TestThread testThread=new TestThread();

        //调用start()方法开启线程。调用run()方法不会实现并发
        testThread.start();

        for(int i=0;i<40;i++){
            System.out.println("看电视");
        }
    }
}

在这里插入图片描述

注：每次执行结果可能不一样

# 1.2 多线程网图下载

可用工具包：https://commons.apache.org/proper/commons-io/download_io.cgi

package Multics;

import org.apache.commons.io.FileUtils;
import java.io.File;
import java.io.IOException;
import java.net.URL;

public class TestThread extends Thread{
    private String url;
    private String name;

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

    //下载图片执行体
    @Override
    public void run() {
        WebDownloader webDownloader=new WebDownloader();
        webDownloader.downloader(url,name);
        System.out.println("下载的文件名为："+name);
    }

    public static void main(String[] args) {
        TestThread t1=new TestThread("https://gimg2.baidu.com/image_search/src=http%3A%2F%2Fup.enterdesk.com%2Fedpic_source%2F1d%2Fd7%2F74%2F1dd7742b0e08837f0afb77d3c9006a75.jpg&refer=http%3A%2F%2Fup.enterdesk.com&app=2002&size=f9999,10000&q=a80&n=0&g=0n&fmt=jpeg?sec=1644976584&t=c01c909514022ae483b88d1f5570fe2d","1.jpg");
        TestThread t2=new TestThread("https://gimg2.baidu.com/image_search/src=http%3A%2F%2Fpic1.win4000.com%2Fwallpaper%2F2020-11-06%2F5fa4dec85d63f.jpg&refer=http%3A%2F%2Fpic1.win4000.com&app=2002&size=f9999,10000&q=a80&n=0&g=0n&fmt=jpeg?sec=1644976692&t=f0ec64a96d2eba5ebd5942bd42381e53","2.jpg");
        TestThread t3=new TestThread("https://gimg2.baidu.com/image_search/src=http%3A%2F%2Fimg.3dmgame.com%2Fuploads%2Fimages%2Fnews%2F20200701%2F1593590839_180447.jpg&refer=http%3A%2F%2Fimg.3dmgame.com&app=2002&size=f9999,10000&q=a80&n=0&g=0n&fmt=jpeg?sec=1644976721&t=6d631b3087b6a7ef424b4d7c74e1aa15","3.jpg");

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

}


//下载器
class WebDownloader{
    public void downloader(String url,String name){
        try {
            FileUtils.copyURLToFile(new URL(url),new File(name));
        } catch (IOException e) {
            e.printStackTrace();
            System.out.println("downloader方法出现IO异常");
        }
    }
}

在这里插入图片描述

# 1.3 实现Runnable接口

// 1.1创建Thread改写
package Multics;

public class TestThread implements Runnable{
    @Override
    public void run() {
        //run方法线程体
        for(int i=0;i<20;i++){
            System.out.println("吃饭");
        }
    }

    public static void main(String[] args) {
        //创建Runnable接口的实现类对象
        TestThread testThread1=new TestThread();

        //创建线程对象，通过线程对象来开启线程，又称代理
        Thread thread=new Thread(testThread1);
        thread.start();
        //上面两行也可以简写成  new Thread(testThread1).start();

        for(int i=0;i<40;i++){
            System.out.println("看电视");
        }
    }
}

package Multics;

import org.apache.commons.io.FileUtils;
import java.io.File;
import java.io.IOException;
import java.net.URL;

public class TestThread implements Runnable{
    
    //......
    
    public static void main(String[] args) {
        //创建t1,t2,t3
		//......
        
        new Thread(t1).start();
        new Thread(t2).start();
        new Thread(t3).start();
        
    }

}


//下载器
//......

继承Thread类	实现Runnable接口
子类继承Thread类具备多线程能力	实现接口Runnable具有多线程能力
启动线程：子类对象.start()	启动线程：传入目标对象+Thread对象.start()
不建议使用：避免OOP单继承局限性	推荐使用：避免单继承的局限性，灵活方便，便于同一个对象被多个线程使用

# 1.4 实现Callable接口（次要）

package Multics;

import org.apache.commons.io.FileUtils;
import java.io.File;
import java.io.IOException;
import java.net.URL;
import java.util.concurrent.*;

/**
*  1.2网图下载改写
*/
public class TestThread implements Callable<Boolean>{
    private String url;
    private String name;

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

    //下载图片执行体
    @Override
    public Boolean call() {
        WebDownloader webDownloader=new WebDownloader();
        webDownloader.downloader(url,name);
        System.out.println("下载的文件名为："+name);
        return true;
    }

    public static void main(String[] args) throws Exception{
        //创建t1,t2,t3
        //......
        
        
        //创建执行服务
        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();

        //关闭服务
        ser.shutdown();
    }
}


//下载器
//......

实现Callable接口的好处：

可以定义返回值
可以抛出异常

# 例子：购买火车票

多个线程操作同一个对象

package Multics;

import org.apache.commons.io.FileUtils;
import java.io.File;
import java.io.IOException;
import java.net.URL;

public class TestThread implements Runnable{

    //剩余票数
    private int ticketNums=10;

    @Override
    public void run() {
        while(true){
            if(ticketNums<=0){
                break;
            }

            //模拟延时
            try {
                Thread.sleep(200);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName()+"-->拿到了第："+ticketNums--+"张票");
        }
    }

    public static void main(String[] args) {
        TestThread ticket=new TestThread();

        new Thread(ticket,"张三").start();
        new Thread(ticket,"李四").start();
        new Thread(ticket,"黄牛").start();
    }
}

在这里插入图片描述

由结果可以看出，多线程代码可能会出现数据不安全的问题。需要用并发方法解决。

# 例子：龟兔赛跑

在这里插入图片描述

package Multics;

public class Race implements Runnable{
    private static String winner;

    @Override
    public void run() {
        for(int i=0;i<=100;i++){

            //模拟兔子偷懒
            if(Thread.currentThread().getName().equals("兔子") && i%30==0){
                try {
                    Thread.sleep(1);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }

            //判断比赛是否结束
            boolean flag=gameOver(i);
            if(flag) {break;}

            System.out.println(Thread.currentThread().getName()+"-->已经跑了"+i+"步");
        }
    }

    //判断是否完成比赛
    private boolean gameOver(int steps){
        //判断胜利者
        if(winner!=null){
            return true;
        }
        if(steps==100){
            winner=Thread.currentThread().getName();
            System.out.println("winner is "+winner);
            return true;
        }
        return false;
    }


    public static void main(String[] args) {
        Race race=new Race();

        new Thread(race,"兔子").start();
        new Thread(race,"乌龟").start();
    }
}

在这里插入图片描述

# 1.5 静态代理模式

真实目标角色和代理角色实现同一个接口。换句话说，真实目标角色可以只实现很小一部分的接口内容，接口的大部分内容可以放到代理角色中实现。

package Multics;

public class StaticProxy{
    public static void main(String[] args) throws Exception{
        WeddingCompany weddingCompany=new WeddingCompany(new You());
        weddingCompany.HappyMarry();
    }
}

interface Marry{
    //一些待实现接口
    //结婚内容1
    //结婚内容2
    //结婚内容3
    //结婚内容4

    void HappyMarry();
}

class You implements Marry{
    @Override
    public void HappyMarry() {
        System.out.println("秦老师要结婚了，超开心");
    }
}

//婚庆公司类
class WeddingCompany implements Marry{
    private Marry target;
    public WeddingCompany(Marry target){
        this.target=target;
    }

    @Override
    public void HappyMarry() {
        before();
        this.target.HappyMarry();
        after();
    }

    private void after(){
        System.out.println("结婚之后，收尾款");
    }
    private void before(){
        System.out.println("结婚之前，布置现场");
    }
    //还可以实现Marry中的其他接口
}

# Lambda表达式

目的：避免匿名内部类定义过多。可以将几乎不常用(比如只在一个地方用过一次)的函数直接写成lambda函数。大体思想和C++的lambda表达式相同。

//三种定义方式
(params)->expression[表达式]
(params)->statement[语句]
(params)->{statements}

//例
a->System.out.println("i like lambda -->"+a);

package Multics;

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 like=new Like();
        like.lambda();

        like=new Like2();
        like.lambda();


        //4.局部内部类
        class Like3 implements ILike{
            @Override
            public void lambda() {
                System.out.println("i like lambda3");
            }
        }
        like=new Like3();
        like.lambda();

        //5.匿名内部类,通过接口声明
        like=new ILike() {
            @Override
            public void lambda() {
                System.out.println("i like lambda4");
            }
        };

        //6.用lambda简化
        like=()->{
            System.out.println("i like lambda5");
        };
        like.lambda();
    }
}

//1.定义一个函数式接口
interface ILike{
    void lambda();
}

//2.实现类
class Like implements ILike{
    @Override
    public void lambda() {
        System.out.println("i like lambda");
    }
}

注：

函数式接口说明接口内只有一个待实现的方法，加入ILike中写了两个待实现方法，那么用lambda表达式就会报错。
lambda表达式中的参数可以不声明类型。

# 2.线程操作

# 2.0 Java线程基本内容

常见线程方法

setPriority(int newPriority)  //更改线程的优先级
static void sleep(long millis)  //指定毫秒内停止当前线程
void join()  //等待该线程终止
static void yield()  //暂停当前正在执行的线程对象，并执行其他线程
void interrupt()  //中断线程
boolean isAlive()  //测试线程是否处于活动状态

线程状态常量 -->Thread.State.常量：

NEW：尚未启动的线程
RUNNABLE: 在Java虚拟机中处于就绪态的线程
BLOCKED: 线程处于阻塞态
WAITING: 线程正在等待另一个线程执行特定动作
TIMED_WAITING：正在等待另一个线程执行动作达到指定等待时间的线程
TERMINATED：结束态

# 2.1 线程停止

建议线程正常停止。不建议死循环。
建议使用自定义的标志位，用于判断线程是否停止
不要使用stop()或destory()等JDK已不建议使用的方法

package Multics;

public class TestStop 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) {
        TestStop testStop=new TestStop();
        new Thread(testStop).start();
        for(int i=0;i<1000;i++){
            System.out.println("测试"+i);
            if(i==900){
                testStop.stop();
                System.out.println("线程强制停止");
            }
        }
    }
}

在这里插入图片描述

# 2.2 线程休眠

sleep存在异常InterruptedException
sleep事件结束后线程进入就绪态
每个对象都有一个锁，sleep不会释放锁

package Multics;

import java.text.SimpleDateFormat;
import java.util.Date;

//模拟网络延时
public class TestSleep{

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

    public static void main(String[] args) {
        Date startTime=new Date(System.currentTimeMillis());//获取系统当前时间

        while(true){
            try {
                Thread.sleep(1000);
                System.out.println(new SimpleDateFormat("HH:mm:ss").format(startTime));
                startTime=new Date(System.currentTimeMillis());//更新当前时间
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

在这里插入图片描述

# 2.3 线程礼让

目的：让当前正在执行的线程暂停，但不进入阻塞态。这个过程不一定成功。

package Multics;

public class TestYield {
    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()+"线程停止执行");
    }
}

在这里插入图片描述

# 2.4 线程强制执行

join()

package Multics;

public class TestJoin 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{
        //启动线程
        TestJoin testJoin=new TestJoin();
        Thread thread=new Thread(testJoin);
        thread.start();

        //主线程
        for(int i=0;i<500;i++){
            if(i==200){  //i==200是有一个vip线程插队
                thread.join();
            }
            System.out.println("main"+i);
        }
    }
}

在这里插入图片描述

# 2.5 线程优先级

优先级用数字表示：1~10

Thread.MIN_PRIOTITY=1;
Thread.MAX_PRIOTITY=10; //最高优先级
Thread.NORM_PRIOTITY=5;

getPriority()   //获取优先级 
setPriority(int x)  //在线程启动前 设置优先级

# 2.6 守护(daemon)线程

线程分为用户线程和守护线程
JVM必须确保用户线程执行完毕如main()函数
JVM不用等待守护线程执行完毕
例：后台记录操作日志，监控内存，垃圾回收......

package Multics;

public class TestDaemon {
    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!=============");
    }
}

在这里插入图片描述

# 3 线程同步

目的：多个线程操作同一个资源。如抢票系统

主要思想：队列+锁(确保安全)。处理多线程问题时，多个线程访问同一个对象，并且某些线程还想修改这个对象。这时候我们就需要线程同步，线程同步其实就是一种等待机制，多个需要同时访问次对象的线程进入这个对象的等待吃形成队列，等待前面线程是哟弄个完毕，下一个线程在使用。

锁机制：为了保证数据在方法中被访问时的正确性，在访问时加入锁机制：synchronized。当一个线程获得对象的排他锁，就可以独占资源，其他线程必须等待，使用完后可以释放锁。

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

# 三大不安全案例

# 1.抢票系统

package Multics;

public class UnsafeBuyTicket{
    public static void main(String[] args) {
        BuyTicket buyTicket = new BuyTicket();
        new Thread(buyTicket,"张三").start();
        new Thread(buyTicket,"李四").start();
        new Thread(buyTicket,"黄牛").start();
    }
}

class BuyTicket implements Runnable{
    //票
    private int ticketNums=10;
    private boolean flag=true;

    @Override
    public void run() {
        while(flag){
            buy();
        }
    }

    private void buy(){
        //判断是否有票
        if(ticketNums<=0) {
            flag=false;
            return;
        }

        //模拟延时
        try {
            Thread.sleep(100);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        //买票
        System.out.println(Thread.currentThread().getName()+"拿到了"+ticketNums--);
    }
}

在这里插入图片描述

线程操作资源时没有上锁，导致线程不安全。

# 2.银行取钱

package Multics;

public class UnsafeBank {
    public static void main(String[] args) {
        Account account=new Account(100,"基金");

        Drawing you=new Drawing(account,50,"你");
        Drawing friend=new Drawing(account,100,"friend");
        you.start();
        friend.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;
    }

    //取钱
    @Override
    public void run() {
        //判断有没有钱
        if(account.money-drawingMoney<0){
            System.out.println(Thread.currentThread().getName()+"余额不足");
            return;
        }

        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        //更新余额与现金
        account.money-=drawingMoney;
        nowMoney+=drawingMoney;

        System.out.println(account.name+"余额为："+account.money);
        System.out.println(this.getName()+"现金："+nowMoney);
    }
}

在这里插入图片描述

# 3.线程安全

package Multics;

import java.util.ArrayList;
import java.util.List;

public class UnsafeList {
    public static void main(String[] args) {
        List<String> list =new ArrayList<String>();
        for(int i=0;i<10000;i++){
            new Thread(()->{
                list.add(Thread.currentThread().getName());
            }).start();
        }
        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(list.size());
    }
}

在这里插入图片描述

# 同步方法

synchronized关键字

public synchronized void method(...){...}

synchronized修饰的方法必须先获得调用该方法对象的锁后才能执行，否则线程会阻塞。

# 1.抢票系统

package Multics;

public class UnsafeBuyTicket{
    public static void main(String[] args) {
        BuyTicket buyTicket = new BuyTicket();
        new Thread(buyTicket,"张三").start();
        new Thread(buyTicket,"李四").start();
        new Thread(buyTicket,"黄牛").start();
    }
}

class BuyTicket implements Runnable{
    //......

    //对this加锁
    private synchronized void buy(){
        //......
    }
}

在这里插入图片描述

# 2.银行取钱

package Multics;

public class UnsafeBank {
    public static void main(String[] args) {
        Account account=new Account(100,"基金");

        Drawing you=new Drawing(account,50,"你");
        Drawing friend=new Drawing(account,100,"friend");
        you.start();
        friend.start();
    }
}


//账户
class Account{...}

//银行  模拟取款
class Drawing extends Thread{
    //......
    
    //取钱
    @Override
    public void run() {
        //通过synchronized块对account上锁。默认上锁this
        synchronized(account){
           //源码套上synchronized块
        }
    }
}

在这里插入图片描述

# 3.线程安全

package Multics;

import java.util.ArrayList;
import java.util.List;

public class UnsafeList {
    public static void main(String[] args) {
        List<String> list =new ArrayList<String>();
        for(int i=0;i<10000;i++){
            new Thread(()->{
                synchronized (list){
                    list.add(Thread.currentThread().getName());
                }
            }).start();
        }
        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(list.size());
    }
}

在这里插入图片描述

也可以使用现成的JUC安全类型集合

package Multics;

import java.util.concurrent.CopyOnWriteArrayList;

public class TestJUC {
    public static void main(String[] args){
        CopyOnWriteArrayList<String> list=new CopyOnWriteArrayList<String>();
        for(int i=0;i<10000;i++){
            new Thread(()->{
                list.add(Thread.currentThread().getName());
            }).start();
        }
        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(list.size());
    }
}

# 4.锁

# 4.1 死锁

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

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

化妆案例

package Multics;

public class DeadDock {
    public static void main(String[] args) {
        Makeup g1=new Makeup(0,"A");
        Makeup g2=new Makeup(1,"B");

        g1.start();
        g2.start();
    }
}

//口红
class Lipstick{ }
//镜子
class Mirror{ }

class Makeup extends Thread{
    //需要的资源都只有一份
    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 (Exception e) {
            e.printStackTrace();
        }
    }

    //化妆，一个人有口红，另一个人有镜子。双方都需要对方的资源
    private void makeup() {
        if (choice == 0) {
            synchronized (lipstick) {  //获得口红的锁
                System.out.println(this.girlName + "获得了口红的锁");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }

                //1s后，想获得镜子的锁
                synchronized (mirror) {  //获得镜子的锁
                    System.out.println(this.girlName + "获得了镜子的锁");
                }
            }
        }
        else {
            synchronized (mirror) {  //获得镜子的锁
                System.out.println(this.girlName + "获得了镜子的锁");
                try {
                    Thread.sleep(2000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }

                //1s后，想获得口红的锁
                synchronized (lipstick) {  //获得口红的锁
                    System.out.println(this.girlName + "获得了口红的锁");
                }
            }

        }
    }
}

在这里插入图片描述

修改代码

package Multics;

public class DeadDock {
    public static void main(String[] args) {
        Makeup g1=new Makeup(0,"A");
        Makeup g2=new Makeup(1,"B");

        g1.start();
        g2.start();
    }
}

//口红
class Lipstick{ }
//镜子
class Mirror{ }

class Makeup extends Thread{
    //......
    //化妆，一个人有口红，另一个人有镜子。双方都需要对方的资源
    private void makeup() {
        if (choice == 0) {
            synchronized (lipstick) {  //获得口红的锁
                System.out.println(this.girlName + "获得了口红的锁");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            
            //1s后，想获得镜子的锁
            synchronized (mirror) {  //获得镜子的锁
                System.out.println(this.girlName + "获得了镜子的锁");
            }
        }
        else {
            synchronized (mirror) {  //获得镜子的锁
                System.out.println(this.girlName + "获得了镜子的锁");
                try {
                    Thread.sleep(2000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            
            //1s后，想获得口红的锁
            synchronized (lipstick) {  //获得口红的锁
                System.out.println(this.girlName + "获得了口红的锁");
            }

        }
    }
}

在这里插入图片描述

# 4.2 Lock锁(JDK)

java.util.concurrent.locks.Lock接口时控制多个线程对共享资源进行访问的工具。锁提供了对共享资源的独占访问，每次只能有一个线程对Lock对象枷锁，线程开始访问共享资源之前应先获得的Lock对象。

ReentrantLock类(可重入锁)实现了Lock，它拥有与synchronized相同的并发性和内存语义，在实现线程安全的控制中，比较常用的是ReentrantLock，可以显示加锁、释放锁。

package Multics;

import java.util.concurrent.locks.ReentrantLock;

//抢票模拟
public class TestLock {
    public static void main(String[] args) {
        TestLock2 testLock2 = new TestLock2();

        new Thread(testLock2).start();
        new Thread(testLock2).start();
        new Thread(testLock2).start();
    }
}

class TestLock2 implements Runnable{

    int ticketNums=10;

    //定义lock锁。默认对this上锁
    private  final ReentrantLock lock=new ReentrantLock();

    @Override
    public void run() {
        while(true){
            try {
                lock.lock();  //显式加锁

                if(ticketNums>=0){
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(ticketNums--);
                }
            } finally {
                lock.unlock(); //显式解锁
            }
        }
    }
}

在这里插入图片描述

sychronized 和Lock对比：

Lock式显式锁。sychronized是隐式锁。后者加锁、释放锁自动完成。
Lock只有代码块锁。sychronized有代码块所和方法锁。
使用Lock锁，JVM将花费较少的时间来调度线程，性能更好。并且具有更好的扩展性(提供更多的子类)
优先使用顺序：Lock>同步代码块>同步方法

# 5.线程通信

# 生产者、消费者问题

前提：

假设仓库中只能存放一件产品，生产者将生产出来的产品放入仓库，消费者将仓库中的产品取走消费。
如果仓库中没有产品，则生产者将产品放入仓库，否则停止生产并等待，知道仓库中的产品被消费者取走为止。
如果仓库中放有产品，则消费者可以将产品取走消费，否则停止消费并等待，知道仓库中再次放入产品为止。

在这里插入图片描述

该问题中，生产者和消费者之间相互依赖，互为条件：

对于生产者，没有生产产品之前，要通知消费者等待。生产了产品之后，有需要马上通知消费者消费。
对于消费者，在消费之后，要通知生产者已经结束消费，需要生产新的产品以供消费。
该问题中，只用synchronized是不够的。1.synchronized可以组织并发更新同一个共享资源，实现了同步。 2.synchronized不能用来实现不同线程之间的消息传递(通信)

//线程通信相关的java方法
wait()  //表示线程已知等待，知道其他线程通知，与sleep不同，会释放锁
wait(long timeout)  //指定等待的毫秒数
notify()  //唤醒一个处于等待状态的线程
notifyAll()  //唤醒同一个对象上所有调用wait()方法的线程，优先级高的线程优先

注：以上均为Object类的方法，都只能在同步方法或同步代码块中使用，否则会抛出异常IllegalMonitorStateException

# 解决方式

# 1.管程法

生产者：负责生产数据的模块(可能是方法，对象，线程，进程)；
消费者：负责处理数据的模块(可能是方法，对象，线程，进程)；
缓冲区：消费者不能直接使用生产者的数据。他们之间有一个缓冲区；

package Multics;

//需要的类：生产者、消费者、产品、缓冲区
public class TestPC {
    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.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;
    }
}

在这里插入图片描述

# 2.信号灯法

package Multics;

//需要的类：生产者、消费者、产品、缓冲区
public class TestPC {
    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("节目A播放中");
            }
            else{
                this.tv.play("节目B播放中");
            }
        }
    }
}

//消费者-->观众
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 {
                this.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;
    }
}

在这里插入图片描述

# 6.线程池

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

思路：提前创建多个线程，放入线程池中，使用时直接获取，食用含放回池中。这样可以避免频繁创建销毁、实现重复利用。如显示生活中的公交车。

优点：

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

JDK5.0起提供了线程池相关API：ExecutorService和Executors

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

void execute(Runnable command):执行任务/命令，没有返回值，一般用来执行Runnable
<T>Future<T>submmit(Callable<T>task):执行任务，有返回值，一般用来执行Callable
void shutdown()：关闭线程池

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

package Multics;

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

public class TestPool {
    public static void main(String[] args) {
        //1.创建服务，创建线程池
        //参数为线程池大小
        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());
    }
}

在这里插入图片描述