标签：java Thread void 学习 start 线程 new 多线程 public

java多线程学习（主要围绕着线程的实现、状态、同步、通信以及高级主题如线程池）

1.线程、进程、多线程

进程：
正在进行中的程序，一个程序的执行过程，需要资源：内存、cpu。
线程：
属于进程，指的是一个可以独立运行的代码片段（执行单元、执行路径）。
一个进程中有多个可以独立运行的执行单元，这样的进程称之为多线程的进程。
一个进程中至少有一个线程，这样的进程称之为叫做单线程的进程。
多线程的进程共享同一块内存空间。
CPU在执行时，某一时刻只能执行一个进程，做着高速的切换动作，导致看到的是貌似同时执行的效果（单核）。CPU执行线程的时间是不确定的。抢占式方式抢占CPU的调度。
同类的线程共享堆和方法区资源，但每个线程私有自己的程序计数器、虚拟机栈、本地方法栈。程序计数器私有是为了线程切换后能恢复到正确的位置。而虚拟机栈和本地方法栈私有是为了线程中的局部变量不被其他的线程访问到。

进程是相互独立的，但同一进程的线程可能会相互影响。

并行和并发：
并行：多个任务同时执行，在某一时刻每个任务都在执行，前提–多核。
并发：多个任务同时执行，在某一时刻只有一个任务在执行，其他任务在等待cpu。

2.继承Thread类(创建线程方式一，但不建议使用)

创建线程：
java.lang包中有一个Thread对象，用于描述线程事物。
主线程：要运行的代码封装到main方法中的。
子线程：要运行的代码封装到run和call方法中。
1.定义类继承Thread类
2.重写run方法
3.创建子线程对象
4.启动线程，调用start方法

//创建线程方式一：继承Thread类，重写run（）方法，主线程调用start（）开启线程。注意run与start不同
//总结：线程开启后不一定立即执行，由cpu调度执行

public class TestThread1 extends Thread{
    @Override
    public void run() {
        //run方法线程体
        for (int i=0;i<200;i++){
            System.out.println("我在看代码---"+i);
        }

    }

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

        //创建一个线程对象
        TestThread1 testThread1 = new TestThread1();

        //调用start开启线程
        testThread1.start();

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

3.网图下载（一个小demo）

maven项目导入依赖

<dependencies>
        <dependency>
            <groupId>commons-io</groupId>
            <artifactId>commons-io</artifactId>
            <version>2.6</version>
        </dependency>
    </dependencies>

自定义下载器

//下载器
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("IO异常，downloader方法出现问题");
        }
    }
}

自定义类继承Thread

//练习Thread，实现多线程同步下载图片
public class TestThread2 extends Thread {

    private String url;//网图地址
    private String name;//文件名

    public TestThread2(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) {
        TestThread2 t1=new TestThread2("https://img-operation.csdnimg.cn/csdn/silkroad/img/1665732353444.jpg","1.jpg");
        TestThread2 t2=new TestThread2("https://img-home.csdnimg.cn/images/20221021091509.png","2.jpg");
        TestThread2 t3=new TestThread2("https://img-operation.csdnimg.cn/csdn/silkroad/img/1666684204807.png","3.jpg");

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


    }

}

4.实现Runnable接口(创建线程方式二，由于java语言单根继承的特性，推荐使用此方法)

实现runnable接口：传入目标对象+Thread对象.start()，好处一个类可以只实例化一次便能创建不同的线程

public class TestThread3 implements Runnable{
    @Override
    public void run() {
        //run方法线程体
        for (int i = 0; i < 200; i++) {
            System.out.println("我在看代码---"+i);
        }
    }

    public static void main(String[] args) {
        //创建runnable接口的实现类对象
        TestThread3 testThread3 = new TestThread3();
        //创建线程对象，通过线程对象来开启我们的线程，代理
        
//        Thread thread = new Thread(testThread3);

//        thread.start();

        new Thread(testThread3).start();

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

}

5.一些简单的并发问题（以下例子为数据会被多个线程访问导致的矛盾）

//多个线程同时操作同一个对象
//买火车票的例子
//问题存在：多个线程操作同一个资源的情况下，线程不安全，数据紊乱，此例中同一张票会被多个线程访问
public class TestThread4 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();
            }
            //Thread.currentThread().getName()返回线程对象的名字
            System.out.println(Thread.currentThread().getName()+"-->拿到了第"+ticketNums--+"张票");
        }
    }

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

        //线程对象的名字依次为小明、老师、黄牛
        new Thread(ticket,"小明").start();
        new Thread(ticket,"老师").start();
        new Thread(ticket,"黄牛").start();

    }
}

6.实现Callable接口（目前作为了解）

1.实现Callable接口，需要返回值类型
2.重写call方法，需要抛出异常
3.创建目标对象
4.创建执行服务：用到ExecutorService和Executor类
5.提交执行
6.获取结果（使用get()方法）
7.关闭服务
案例如下(重写一遍之前的网图下载)

//线程创建方式三：实现callable接口
public class TestCallable implements Callable<Boolean> {

    private String url;//网图地址
    private String name;//文件名

    public TestCallable(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 ExecutionException, InterruptedException {
        TestCallable t1=new TestCallable("https://img-operation.csdnimg.cn/csdn/silkroad/img/1665732353444.jpg","1.jpg");
        TestCallable t2=new TestCallable("https://img-home.csdnimg.cn/images/20221021091509.png","2.jpg");
        TestCallable t3=new TestCallable("https://img-operation.csdnimg.cn/csdn/silkroad/img/1666684204807.png","3.jpg");

        //创建执行服务
        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 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("IO异常，downloader方法出现问题");
        }
    }
}

7.静态代理模式

关于静态代理模式，我是这样认为的，假如很多人想要结婚，但是结婚会花很多精力，于是就有婚庆公司帮助我们完成结婚的很多事情
所以我们就不需要自己去进行这些工作。假如Marry是“结婚”这一事件，you是需要结婚的人，weddingcompany是婚庆公司，那么
可以精简为，you和weddingcompany都具有实现Marry这个功能的能力，但是我们只让weddingcompany去做，那么可以由下述
代码去完成这个任务

package com.kuang.demo02;

//静态代理模式：真实对象与代理对象都要实现同一接口
//代理对象要代理真实的角色，比如婚庆公司要帮对象策划结婚

//好处：代理角色可以做很多真实对象做不了的事
        //真实对象只需专注自己的事
public class StaticProxy {
    public static void main(String[] args) {
        You you=new You();
        
        //lambda表达式
        new Thread(()-> System.out.println("我爱你")).start();

        new WeddingCompany(new You()).HappyMarry();

//        WeddingCompany weddingCompany=new WeddingCompany(new you());
//        weddingCompany.HappyMarry();
    }

}

interface Marry{
    void HappyMarry();
}

class You implements Marry{

    @Override
    public void HappyMarry() {
        System.out.println("666");
    }
}

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("准备");
    }
}

8.lambda表达式

函数式接口：只包含唯一一个抽象方法,如

public interface Runnable(){
    public abstract void run();
}

对于函数式接口，我们可以使用lambda表达式来创建该接口的对象，下面的代码，首先声明了一个接口，
在主函数中用lambda表达式输出。如果有多个参数则函数形参列表的括号和花括号不可省略，但是可以省略形参的类型

public class TestLambda2 {
    public static void main(String[] args) {
        ILove love=a->{
            System.out.println("i love you "+a);};
        love.love(5);
    }
}
interface ILove{
    void love(int a);
}

9.线程的状态

线程的状态大致有新生、就绪、运行、阻塞、死亡状态。具体参考操作系统课程所学
常用的方法有setPriority(int )更改线程优先级、static void sleep(long )使当前线程休眠指定的毫秒时长、
void join()等待该线程终止、static void yield()暂停当前正在执行的线程对象并执行其他线程、void interrupt()
中断线程但不要使用这个方式、boolean isAlive()测试线程是否处于活动状态
停止线程的最好方式，是让线程自己停下，在类的内部声明私有标志位并提供方法改变标志位挡flag=false，则终止线程,代码示例如下

package com.kuang.demo02;
//测试停止线程
//1.建议线程正常停止，利用次数但不建议死循环
//2.建议使用标志位
//3，不要使用stop或者destory等等过时或JDK不建议使用的方法
public class TestStop implements Runnable{
    private boolean flag=true;
    @Override
    public void run() {
        int i=0;
        while (this.flag){
            System.out.println("run ... Thread "+i++);
        }
    }
    //设置公开方法停止线程，转换标志位
    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("main "+i);
            if (i==900){
                testStop.stop();
                System.out.println("线程已停止");
            }
        }
    }
}

10.线程休眠

sleep指定当前线程阻塞的毫秒数，会存在异常InterruptedException;sleep时间到后线程进入就绪态。

sleep还可以模拟网络延时，倒计时等等。每一个对象都有一把锁，sleep不会释放锁
以下是网络延时的一个小demo

package com.kuang.demo03;
//模拟网络延时的例子:为了放大问题的发生性
public class TestSleep 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();
            }
            //Thread.currentThread().getName()返回线程对象的名字
            System.out.println(Thread.currentThread().getName()+"-->拿到了第"+ticketNums--+"张票");
        }
    }
    public static void main(String[] args) {
        TestSleep ticket = new TestSleep();
        //线程对象的名字依次为小明、老师、黄牛
        new Thread(ticket,"小明").start();
        new Thread(ticket,"老师").start();
        new Thread(ticket,"黄牛").start();
    }
}

10.线程礼让

礼让的意思就是让当前正在执行的线程暂停，但不阻塞它。并将另一线程从运行态
转为就绪态。实际上是让cpu重新调度，礼让不一定能成功，根据cpu状态来进行。

package com.kuang.demo03;
//测试礼让线程
//礼让不一定成功，得看cpu状态,实质是cpu重调度
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()+"停止");
    }
}

11.合并线程join

类似于插队行为，其他线程要让步给此线程,以下是示例，当i=200时，将停止主线程，直到线程vip执行完成。

package com.kuang.demo03;
//测试join方法，类似插队
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 < 1000; i++) {
            if(i==200){
                thread.join();//插队
            }
            System.out.println("main "+i);
        }
    }
}

12.线程状态观测 Thread.State

package com.kuang.demo03;

//观察和测试线程的状态
public class TestState {
    public static void main(String[] args) throws InterruptedException {
        //lambda表达
        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);//new
        //观察启动后
        thread.start();
        state = thread.getState();
        System.out.println(state);//Run
        while (state!=Thread.State.TERMINATED){//线程不终止，就一直输出状态
            Thread.sleep(100);
            state=thread.getState();//更新线程状态
            System.out.println(state);//输出状态
        }
//        thread.start();//这句代码会报错，因为死亡的线程无法启动两次
    }
}

13.线程优先级，优先级高则被调度器调度的概率高

线程优先级数据范围从1-10，

Thread.MIN_PRIORITY=1;
Thread.MAX_PRIORITY=10;
Thread.NORM_PRIORITY=5;
//以下是获取优先级和改变优先级的方式
getPriority(),setPriority(int xxx)

具体的代码示例如下，运行的结果并不按照优先级的大小

package com.kuang.demo03;
public class TestPriority{
    public static void main(String[] args) {
       //主线程默认优先级
        System.out.println(Thread.currentThread().getName()+"-->"+Thread.currentThread().getPriority());
        MyPriority myPriority = new MyPriority();
        Thread t1 = new Thread(myPriority);
        Thread t2 = new Thread(myPriority);
        Thread t3 = new Thread(myPriority);
        Thread t4 = new Thread(myPriority);
        Thread t5 = new Thread(myPriority);
        Thread t6 = new Thread(myPriority);
        //一定要先设置优先级，再启动
        t1.start();
        t2.setPriority(1);
        t2.start();
        t3.setPriority(4);
        t3.start();
        t4.setPriority(Thread.MAX_PRIORITY);//MAX_PRIORITY=10
        t4.start();
        t5.setPriority(7);
        t5.start();
        t6.setPriority(9);
        t6.start();
    }
}
class MyPriority implements Runnable{
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName()+"-->"+Thread.currentThread().getPriority());
    }
}

14.守护线程

线程分为用户线程和守护线程，虚拟机需确保用户线程执行完毕
但虚拟机不用等待守护线程执行完毕，如后台记录操作日志、监控内存、垃圾回收等待..
以下程序应该是死循环，但运行后会发现程序会终止，这是因为虚拟机不管守护线程，用户线程结束，则虚拟机终止程序

package com.kuang.demo03;
//测试守护线程
//如上帝守护你
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表示是用户线程，true为守护线程，正常的线程都是用户线程
        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!");
    }
}

15.线程同步

即多个线程操作同一个资源（并发），通俗说来就是同一个对象被多个线程同时操作，比如现实中的抢票、银行取钱
实际上是一种等待机制，多个需要同时访问此对象的线程进入这个对象的等待池形成队列，等待前面的线程使用完毕，
下一个线程再使用。在这个过程中，需要使用队列和锁，来解决线程的同步安全性。

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

1.一个线程持有锁会导致其他所有需要此锁的线程挂起；

2.在多线程竞争下，加锁，释放锁会导致比较多的上下文切换和调度延时，引起性能问题；

3.如果一个优先级高的线程等待一个优先级低的线程释放锁，会导致优先级的倒置，引起性能问题

以下是一个小demo，示例买票不安全的线程例子

package com.kuang.syn;
//买票中的线程不安全问题，这个demo运行的结果会出现票数为0和-1的情况
public class UnsafeBuyTicket {
    public static void main(String[] args) {
        BuyTicket station = new BuyTicket();
        new Thread(station,"我").start();
        new Thread(station,"你").start();
        new Thread(station,"黄牛").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();
            }
        }
    }

    private void buy() throws InterruptedException {
        //是否有票
        if (ticketNums<=0){
            flag=false;
            return;
        }
        //模拟延时
        Thread.sleep(1);
        System.out.println(Thread.currentThread().getName()+"拿到"+ticketNums--);
    }
}

16.同步方法和同步块

由于可以通过private关键字来保证数据对象只能通过方法访问，所以我们只需要对方法提出一套机制，这套机制就
是synchronized方法和synchronized块。

同步方法：public synchronized void method(int args){}

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

缺陷：若将一个大的方法声明为synchronized, 将会影响效率。可以这样理解，一个大的方法如果包含了读和写的
功能，如果对”读“这一功能也加了锁，那么其实是没有必要的，只有对”写“这个功能加锁才是必要的

以下是一个安全的抢票demo

package com.kuang.syn;
//买票中的线程不安全问题，这个demo运行的结果会出现票数为0和-1的情况
public class SafeBuyTicket {
    public static void main(String[] args) {
        BuySafeTicket station = new BuySafeTicket();
        new Thread(station,"我").start();
        new Thread(station,"你").start();
        new Thread(station,"黄牛").start();
    }
}
class BuySafeTicket implements Runnable{
    //票
    private int ticketNums=50;
    boolean flag=true;
    @Override
    public void run() {
        //买票
        while (flag) {
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            buy();
        }
    }
    //声明为同步方法,锁的应该是需要修改的数据（即共享的资源）
    private synchronized void buy(){
        //是否有票
        if (ticketNums<=0){
            flag=false;
            return;
        }
        System.out.println(Thread.currentThread().getName()+"拿到"+ticketNums--);
    }
}

同步块：synchronized(Obj){}
Obj称为同步监视器，其可以是任何对象，但推荐使用共享资源作为同步监视器。同步方法中无需指定同步监视器，因为同步方法
的同步监视器就是this（即此方法所属的实例对象)

同步监视器的执行过程：

1.第一个线程访问，锁定同步监视器。

2.第二个线程访问，发现同步监视器被锁定，无法访问。

3.第一个线程访问完毕，解锁同步监视器。

4.第二个线程访问，发现同步监视器没有锁，于是锁定并访问。

以下是一个安全取钱的小demo。注意，锁的对象是需要增删改的对象

package com.kuang.syn;
//安全的取钱
//两个人去银行取钱
public class SafeBank {
    public static void main(String[] args) {
        //账户
        SafeAccount account = new SafeAccount(1000,"结婚基金");
        SafeDrawing you = new SafeDrawing(account,50,"你");
        SafeDrawing girlFriend = new SafeDrawing(account,100,"girlFriend");
        you.start();
        girlFriend.start();

    }
}

//账户
class SafeAccount{
    int money;
    String name;

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

//银行
class SafeDrawing extends Thread{
    SafeAccount account;
    //取钱数额
    int drawingMoney;
    //手上的钱
    int nowMoney;
    public SafeDrawing(SafeAccount account,int drawingMoney,String name){
        super(name);
        this.account=account;
        this.drawingMoney=drawingMoney;
    }
    @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);
            System.out.println(this.getName()+"手里的钱："+nowMoney);
        }
    }
}

17.死锁

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

产生死锁的必要条件（4点）：

1.互斥：一个资源每次只能被一个线程使用。

2.请求与保持条件：一个线程因请求资源而阻塞时，对已获得的资源不释放。

3.不剥夺条件：线程已获得的资源，在未使用完之前，不能强行剥夺。

4.循环等待条件：若干线程之间形成一种头尾相接的循环等待资源关系。

以下是一个小demo

package com.kuang.syn;
//死锁：多个线程互相抱着对方需要的资源，僵持
public class DeadLock {
    public static void main(String[] args) {
        Makeup you = new Makeup(0, "you");
        Makeup me = new Makeup(1, "me");
        you.start();
        me.start();
    }
}
//口红
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;
    }
    @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(100);
                }
            synchronized (mirror){
                //延时后获得镜子锁
                System.out.println(this.girlName+"获得镜子锁");
            }
        }else {
            synchronized (mirror){
                System.out.println(this.girlName+"获得镜子锁");
                Thread.sleep(200);
                }
            synchronized (lipStick){
                System.out.println(this.girlName+"获得口红锁");
            }
        }
    }
}

18.Lock(锁)

从JDK5.0开始，java提供了更强大的线程同步机制——通过显示定义同步锁对象来实现同步。同步锁使用Lock对象更充当。

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

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

synchronized与Lock的对比：

1.Lock是显式锁（手动开启和关闭），synchronized是隐式锁，出了作用域自动释放

2.Lock只有代码块锁，synchronized有代码块锁和方法锁

3.使用Lock锁，JVM将花费较少的时间来调度线程，性能更好，并且扩展性也更好（因为提供了更多的子类）

4，优先使用顺序：Lock > 同步代码块 > 同步方法

以下是一个买票的小demo，展示了Lock的用法

package com.kuang.LockStudy;
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锁
    private final ReentrantLock lock=new ReentrantLock();
    @Override
    public void run() {
        while (true) {
            try {
                lock.lock();//加锁
                if (ticketNums > 0) {
                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(ticketNums--);
                }else {
                    break;
                }
            }finally {
                lock.unlock();//解锁
            }
        }
    }
}

19.线程协作（生产者 P 消费者 C 问题）

假设仓库中只能存放一件产品，生产者将生产出来的产品放入仓库，消费者将仓库中的产品取走并消费。

如果仓库中没有产品，则生产者将产品放入仓库，否则停止生产并等待，直到仓库中的产品被消费者取走。

如果仓库中放有产品，则消费者将产品取走消费，否则停止消费并等待，直到仓库中再次放入产品。

分析上述问题，生产者和消费者共享一个资源并且两者互相依赖互为条件。

1.对于生产者，没有生产产品之前，要通知消费者等待，而生产了产品后需要通知消费者来消费。

2.对于消费者，消费后要通知生产者结束消费，需要生产产品。

3.在生产者消费者问题中，仅用synchronized不够，这是因为synchronized可阻止并发更新同一个共享资源，
实现同步。但是synchronized不能用来实现不同线程之间的消息传递（通信）。

java提供了几个方法解决线程通信问题。

wait（），表示线程一直等待，直到其他线程通知，与sleep不同的是，wait方法会释放锁。

wait(long timeout) 指定等待的毫秒数

notify() 唤醒一个处于等待状态的线程

notifyAll() 唤醒同一个对象上所有调用wait（）方法的线程，优先级高的线程优先调度

需要注意的是，以上方法均是Object类的方法，只能在同步方法或者同步代码块中使用，否则抛出异常

解决生产者消费者问题的方法：

1.并发协作模型”生产者/消费者模式" -->管程法

生产者：负责生产数据的模块
消费者：负责处理数据
缓冲区：消费者不直接使用生产者生产的数据，生产者将产品放入缓冲区，消费者从缓冲区取数据
以下是一个管程法的小demo

package com.kuang.LockStudy;

//管程法解决P C问题
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++) {
            try {
                container.push(new Chicken(i));
                System.out.println("生产力"+i+"只鸡");

            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

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

    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            try {
                System.out.println("消费了-->"+container.pop().id+"只鸡");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

}

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

class SynContainer{
    //需要一个容器
    Chicken[] chickens=new Chicken[10];
    int count;

    //生产者放入产品
    public synchronized void push(Chicken chicken) throws InterruptedException {
        //容器满了，通知消费者消费
        if(count==chickens.length){
            this.wait();
        }
        //没满，则丢入产品
        chickens[count]=chicken;
        count++;

        //通知消费者消费
        this.notifyAll();
    }

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

        //如果可以消费
        count--;
        Chicken chicken=chickens[count];
        //消费完成，通知生产者生产
        this.notifyAll();
        return chicken;
    }

}

2.信号灯法

核心其实就是利用标志位，以下是信号灯法的一个小demo

package com.kuang.LockStudy;

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) {
                try {
                    this.tv.play("快乐大本营播放");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }else {
                try {
                    this.tv.play("播放抖音");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

//消费者-》关注
class Watcher extends Thread {
    TV tv;

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

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

//产品-》节目
class TV {
    //演员表演，观众等待 T
    //观众观看，演员等待 F
    String voice;//表演的节目
    boolean flag = true;
    //表演
    public synchronized void play(String voice) throws InterruptedException {
        if (!flag) {
            this.wait();
        }
        System.out.println("演员表演了：" + voice);
        this.notify();
        this.voice = voice;
        this.flag = !this.flag;
    }

    //观看
    public synchronized void watch() throws InterruptedException {
        if (flag) {
            this.wait();
        }
        System.out.println("观看了：" + voice);
        this.notify();
        this.flag = !this.flag;
    }
}

20.线程池

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

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

好处：

提高了响应速度
降低资源的消耗
便于线程管理

一些常用的常量和方法：

corePoolSize：核心池的大小
maximumPoolSize: 最大线程数
keepAliveTime：线程没有任务时最长保留时间

线程池的使用：

线程池相关的API:ExecutorService、Executors
ExecutorService:真正的线程池接口。常用的子类ThreadPoolExecutor

void execute(Runnable command):执行任务\命令，无返回值，一般用来执行 Runnable

void shutdown():关闭连接池

Future submit(Callable task):执行任务，有返回值，一般用来执行Runnable

以下是使用的demo：

package com.kuang.LockStudy;

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(5);
        service.execute(new MyThread());
        service.execute(new MyThread());
        service.execute(new MyThread());
        service.execute(new MyThread());
        service.shutdown();
    }


}

class MyThread implements Runnable{

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

    }
}

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

21.总结

实际上都是围绕着线程创建的三种方式：

继承Thread类
实现Runnable接口
实现Callable接口

标签：java,Thread,void,学习,start,线程,new,多线程,public
From： https://www.cnblogs.com/hggBolg/p/17473191.html

java多线程基础的学习