多线程详解（Java.Thread）

线程简介

多任务多线程
普通方法调用和多线程
Process 进程：就是程序执行的一次执行过程，它是一个动态的概念，是系统资源分配的单位

Thread 线程：通常在一个进程中可以包含若干个线程，每一个进程中至少含有一个线程（main主线程），不然没有存在的意义。线程是CPU调度和执行的单位。
注意：很多多线程是模拟出来的，真正的多线程是指有多个CPU，即多核，如服务器。

如果是模拟出来的多线程，就是在一个CPU的情况下，在同一个时间点，CPU只能执行一个代码，因为切换的快，所以就有在同时执行的错觉。

本章核心概念

线程就是独立的执行路径
在程序运行时，即使没有自己创建线程，后台也会有多个线程，如主线程（main）,gc线程（垃圾回收机制）。
main()称之为主线程，为系统入口，用于执行程序
在一个进程中，如果开辟了多个线程，线程的运行由调度器安排调度，调度器是与操作系统紧密相关的。先后顺序是不能认为干预的。
对同一份资源操作时，会存在资源抢夺问题，需要加入并发控制。
线程会带来额外的开销，如CPU调度时间，并发控制开销。
每个线程在自己的工作内存交互，内存控制板不当会造成数据不一致

线程创建

三种创建方式

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

Thread

（学习提醒：查看jdk帮助文档）

自定义线程类继承Thread类
重写run()方法，编写线程执行体
创建线程对象，调用start()方法启用线程
线程不一定立即执行，由CPU安排调度

练习

package com.LTF.Thread1.test1;

//创建线程方式一：继承Thread类，重写run()方法，调用start开启线程
public class TestThread1 extends Thread{

    @Override
    public void run() {
        //方法线程体
        for (int i = 0; i < 20; i++) {
            System.out.println("我在学习代码中……"+i);

        }
    }

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

        //创建一个线程对象testThread1
        TestThread1 testThread1 = new TestThread1();
        //调用start()方法开启线程
        testThread1.start();

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

案例：下载图片

package com.LTF.Thread1.test1;
//文件工具包类
import org.apache.commons.io.FileUtils;

import java.io.File;
import java.io.IOException;
import java.net.URL;

//练习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() {
        //重写run方法，run方法是线程中的一个执行体
        //下载图片线程的执行体
        WebDownloader webDownloader =new WebDownloader();
        webDownloader.downloader(url,name);
        System.out.println("下载了文件名为"+name);
    }

    public static void main(String[] args) {
        //在主方法中创建了三个线程，t1,t2,t3
        testThread2 t1 =new testThread2("https://i0.hdslb.com/bfs/archive/65b588a85a9a98430ca609755f817e585d9360ed.jpg","1.jpg");
        testThread2 t2 =new testThread2("https://i0.hdslb.com/bfs/archive/65b588a85a9a98430ca609755f817e585d9360ed.jpg","2.jpg");
        testThread2 t3 =new testThread2("https://i0.hdslb.com/bfs/archive/65b588a85a9a98430ca609755f817e585d9360ed.jpg","3.jpg");

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

//下载器
class WebDownloader {

    //下载方法
    public void downloader(String url,String name){
        try {
            //copyURLToFile方法是吧网络中的一个网页地址变成一个文件
            //需要丢入一个url 和 name
            FileUtils.copyURLToFile(new URL(url),new File(name));
        } catch (IOException e) {
            e.printStackTrace();
            System.out.println("IO异常，downloader方法出现问题");
        }
    }
}

思路：我们需要实现多线程下载图片，

1.首先写了一个下载器，下载器中有一个下载方法downloader,下载方法是通过我们导入的一个FileUtil的工具包中的copyURLToFile方法完成的，在这里我们需要丢入两个属性url和name

2.我们需要利用多线程，所以在这里让testThread类继承线程类，封装两个属性url（网络图片的地址）和name（保存文件的名字），利用构造器丢入

3.我们在继承了线程类的时候，就必须重写线程类中的run()方法，run()方法是线程中的一个执行体，在这里是下载图片线程的执行体，实例化一个下载器对象，让下载器对象通过下载方法利用两个属性下载图片

4.在主方法中创建若干个线程（）构造器对象，丢入两个实际属性，最后通过start()方法启动线程。

实现Runnable

（学习提示：查看JDK帮助文档）

定义MyRunnable类实现Runnable接口
实现run()方法，编写线程执行体
创建线程对象，调用start()方法启动线程
推荐使用Runnable对象，因为Java单继承的局限性

练习

package com.LTF.Thread1.test1;

//创建线程方法2：实现Runnable接口，重写run方法，执行线程需要丢入runnable接口实现类，调用start方法
public class TestThread3 implements Runnable{
    @Override
    public void run() {
        //方法线程体
        for (int i = 0; i < 20; i++) {
            System.out.println("我在学习代码中……"+i);
        }
    }

    public static void main(String[] args) {
        //创建一个runnable接口的实现类对象testThread3
        TestThread3 testThread3 = new TestThread3();
//        //创建线程对象，通过线程对象来开启我们的线程，代理
//        Thread thread = new Thread(testThread3);
//        //调用start()方法开启线程
//        thread.start();
        //上面两句可以总结为下面这一句
        new Thread(testThread3).start();
        
        for (int i = 0; i < 200; i++) {
            System.out.println("我在学习多线程。。。"+i);
        }
    }
}

小结：

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

初识并发问题

多个线程操作同一资源时，并发

例子：买车票

package com.LTF.Thread1.test1;
//多个线程操作同一个对象

//模拟买票，多个人买票
//发现问题：多个线程操作同一个资源的情况下，线程不安全，出现数据紊乱的情况。
public class TestThread4 implements Runnable{

    private int ticketNum = 10;
    @Override
    public void run() {
        while(true){
            if (ticketNum<=0){
                break;
            }

            //模拟延时，否则cpu执行太快
            try {
                Thread.sleep(200);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

            System.out.println(Thread.currentThread().getName()+"--》买了第"+ticketNum--+"张票");

        }
    }

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

        new Thread(ticket,"小明").start();
        new Thread(ticket,"小红").start();
        new Thread(ticket,"小钢").start();
        new Thread(ticket,"黄牛党").start();

    }
}

例子2：模拟龟兔赛跑问题

package com.LTF.Thread1.test1;

public class Race implements Runnable{

    //用静态来保证只有一个winner
    private static String winner;

    @Override
    public void run() {

        for (int i = 0; i <= 100; i++) {
            boolean flag = gameOver(i);
            //如果比赛结束就退出程序
            if(flag){
                break;
            }
            //内定兔子是要睡觉的，延时
            if(Thread.currentThread().getName()=="兔子"&& i%10==0){
            try {
                Thread.sleep(20);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            }
            System.out.println(Thread.currentThread().getName()+"-->跑了"+i+"米");
        }
    }
    //判断是谁赢得了比赛，
    private boolean gameOver(int steps){
        if(winner != null){  //是否有胜利者，比赛是否结束
           return true;
        } else if (steps == 100) {
                winner = Thread.currentThread().getName();
                System.out.println("胜利者是-->" + winner);
                return true;
            }
        return false;   //
    }

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

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

实现Callable接口

（了解即可，Thread和Runnable是重点）

实现Callable接口，需要返回类型
重写call()方法，需要抛出异常
创建目标对象
创建执行服务：ExecutorService ser = Executors.newFixedThreadPool(1);
提交执行：Future result1 = ser.submit(t1);
获取结果：boolean r1 = result1.get();//需要抛出异常
关闭服务：ser.shutdownNow();

例子：用callable接口实现下载图片

package com.LTF.Thread1.test2;

import org.apache.commons.io.FileUtils;

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

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() {
        //重写run方法，run方法是线程中的一个执行体
        //下载图片线程的执行体
        WebDownloader webDownloader =new WebDownloader();
        webDownloader.downloader(url,name);
        System.out.println("下载了文件名为"+name);
        return true;
    }

    public static void main(String[] args) throws ExecutionException, InterruptedException {
        //在主方法中创建了三个线程，t1,t2,t3
        testCallable t1 =new testCallable("http://i2.hdslb.com/bfs/face/83bb511365da513c55aa3d1958524f3b7db40684.jpg","1.jpg");
        testCallable t2 =new testCallable("http://i2.hdslb.com/bfs/face/83bb511365da513c55aa3d1958524f3b7db40684.jpg","2.jpg");
        testCallable t3 =new testCallable("http://i2.hdslb.com/bfs/face/83bb511365da513c55aa3d1958524f3b7db40684.jpg","3.jpg");

        //1. 创建执行服务：
        ExecutorService ser = Executors.newFixedThreadPool(3);

        //2. 提交执行：
        Future<Boolean> result1 = ser.submit(t1);
        Future<Boolean> result2 = ser.submit(t2);
        Future<Boolean> result3 = ser.submit(t3);

        //3. 获取结果：
        boolean r1 = result1.get();//需要抛出异常
        boolean r2 = result2.get();
        boolean r3 = result3.get();
        System.out.println(r1);
        System.out.println(r2);
        System.out.println(r3);

        //4. 关闭服务：
        ser.shutdownNow();
    }
}

//下载器
class WebDownloader {

    //下载方法
    public void downloader(String url, String name) {
        try {
            //copyURLToFile方法是吧网络中的一个网页地址变成一个文件
            //需要丢入一个url 和 name
            FileUtils.copyURLToFile(new URL(url), new File(name));
        } catch (IOException e) {
            e.printStackTrace();
            System.out.println("IO异常，downloader方法出现问题");
        }
    }
}

静态代理

真实角色：专注做自己的事情

代理角色：可以帮真实角色做真实角色做不了的事情

静态代理模式总结：

真实对象和代理对象都要实现同一个接口，代理对象要代理真实对象，

例子：

package com.LTF.Thread1.test3;

//模拟结婚
public class StaticProxy {
    public static void main(String[] args) {
        You you = new You();
        new WeddingCompany(you).Marry();

       // WeddingCompany weddingCompany = new WeddingCompany(new You());
       // weddingCompany.Marry();
    }
}

//1.结婚接口
interface Marry{
    //结婚方法
    void Marry();
}

//真实角色：你
class You implements Marry{
    @Override
    public void Marry() {
        System.out.println("我要结婚了，非常开心呢");
    }
}
//代理角色：婚庆公司
class WeddingCompany implements Marry{

    //声明一个结婚代理目标人
    private  Marry target;
    //构造方法
    public WeddingCompany(Marry target){
        this.target = target;
    }

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

    private void after() {
        System.out.println("结婚之后，婚庆公司收取尾款");
    }

    private void before() {
        System.out.println("结婚之前，婚庆公司收取定金，布置婚礼现场，准备举行婚礼");
    }
}

Lambda表达式

为什么要使用lambda表达式
- 避免匿名内部类定义过多
- 可以让你的代码看起来更加简洁
- 去掉了一堆没有意义的代码，只留下核心的逻辑

理解Functional interface（函数式接口）是学习Java8 lambda表达式的关键

函数式接口的定义：
- 任何接口，如果只包含唯一一个抽象方法，那么它就是一个函数式接口。
```
//例如
public interface Runnable{
    public abstract void run();
}
```
- 对于函数式接口，我们可以通过lambda表达式来创建该接口的对象
总结：
- lambda表达式只能是有一行代码的情况下才能简化为一行，如果有多行，那么就用代码块。
- 前提是：接口是函数式接口
- 多个参数也可以去掉参数类型，要去掉就都去掉，必须加上括号。

package com.LTF.Thread1.testLambda;

//lamdba表达式简化推理
public class TestLambda {
        //3.静态内部类
        static class Want2 implements Iwant{
            @Override
            public void lambda() {
                System.out.println("I want to eat...orange");
            }
        }

    public static void main(String[] args) {
        Iwant w1 = new Want();
        w1.lambda();
        
        Iwant w2 =new Want2();
        w2.lambda();
        
        //4.局部内部类
        class Want3 implements Iwant{
            @Override
            public void lambda() {
                System.out.println("I want to eat...banana");
            }
        }
        
        Iwant w3 = new Want3();
        w3.lambda();
        
        //5.匿名内部类
       Iwant w4 = new Iwant() {
           @Override
           public void lambda() {
               System.out.println("I want to eat...peach");
           }
       };
       w4.lambda();
       
       //6.利用lamdba表达式 可以不要类名，不要方法名
        Iwant w5 = ()-> {
            System.out.println("I want to eat...pear");
        };
        w5.lambda();
        //lamdba表达式，如果是一句话可以不用花括号，如果多句话，可以用代码块（花括号括起来）
    }
}

//1.写一个函数式接口：只有一个抽象方法的接口
interface Iwant{
    void lambda();//不需要设为抽象，本身在接口内部就是抽象的。
}
//2.实现类
class Want implements Iwant{
    @Override
    public void lambda() {
        System.out.println("I want to eat...apple");
    }
}

线程的五大状态

在这里插入图片描述

停止线程

不推荐使用jdk提供的stop()、destroy()方法。【已废弃】
推荐线程自己停止下来–>利用次数。
建议使用一个标志位进行终止变量当flag=false,则终止线程运行。
例子：让主线程main利用次数自己停下来，让Thread利用标志位停下来

package com.LTF.ThreadState;

//测试线程停止，
//1.建议线程能够正常停止，-->例如利用次数，不建议死循环
//2.建议使用标志位
//3.不要使用stop或者destroy等过时的，又或者jdk不建议使用的方法

public class testStop implements Runnable{
    //1.首先设置一个标志位
    private Boolean flag = true;
    @Override
    public void run() {
        int i = 0;
        while(flag){
            System.out.println("Thread is running..."+i++);
        }
    }
    //2.自己设置一个公开的stop方法让线程停止，将标志位转换为false；
    public void stop(){
        this.flag = false;
    }

    public static void main(String[] args) {
        testStop t1 =new testStop();
        new Thread(t1).start();

        for (int i = 0; i < 1000; i++) {
            System.out.println("main is running..."+i);
            //当主线程运行到900时，让Thread停止
            if(i==900){
                t1.stop();
                System.out.println("线程要停止了。。。"+i);
            }
        }
    }
}

线程休眠

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

模仿网络延时是为了：放大问题的发生性。

1000毫秒=1秒

例子1：模拟网络延时：

package com.LTF.ThreadState;

//模拟网络延时：作用是为了放大问题的发生性，cpu运行太快，会导致问题的发生性小

public class testSleep1 implements Runnable{

    private int ticketNum = 10;
    @Override
    public void run() {
        while(true){
            if (ticketNum<=0){
                break;
            }
            //模拟延时，否则cpu执行太快
            try {
                Thread.sleep(300);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName()+"--》买了第"+ticketNum--+"张票");
        }
    }
    public static void main(String[] args) {
        testSleep1 ticket = new testSleep1();

        new Thread(ticket,"小明").start();
        new Thread(ticket,"小红").start();
        new Thread(ticket,"小钢").start();
        new Thread(ticket,"黄牛党").start();

    }
}

例子2：模拟倒计时：

package com.LTF.ThreadState;

import java.text.SimpleDateFormat;
import java.util.Date;
//模拟倒计时。
public class testSleep2 {
    public static void main(String[] args)  {
        //2.获取系统当前时间
        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();
            }
        }
        //1.倒计时
//        try {
//            Time1();
//        } catch (InterruptedException e) {
//            e.printStackTrace();
//        }
    }

public static void Time1() throws InterruptedException {
     int num = 10;

     while(true){
         Thread.sleep(1000);
         System.out.println(num--);
         if(num<=0){
             break;
         }
     }
    System.out.println("炸弹爆炸，嘣。。。");
    }
}

线程礼让（yield）

礼让线程，让当前正在执行的线程暂停，但是不会阻塞
将线程从运行状态转为就绪状态
让cpu重新调度，礼让不一定成功，关键是CPU。

package com.LTF.ThreadState;

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();//线程礼让，看CPU的调度，礼让不一定成功。
        System.out.println(Thread.currentThread().getName()+"线程停止了");
    }
}

线程强行执行（join）

join合并线程，待此线程执行完成后，再执行其它线程，其它线程会被阻塞。
可以想象成线程插队。
join()存在异常InterruptedException;

例子：

package com.LTF.ThreadState;

public class testJoin implements Runnable{

    public static void main(String[] args) throws InterruptedException {
        testJoin testJoin1 = new testJoin();
        Thread thread = new Thread(testJoin1);
        thread.start();

        for (int i = 0; i < 500; i++) {
            System.out.println("main线程在执行中……"+i);
            if(i==200){
                thread.join();//主线程被阻塞
            }
        }
    }

    @Override
    public void run() {
        System.out.println("VIP线程来插队了");
        for (int i = 0; i < 100; i++) {
            System.out.println("VIP线程执行中……"+i);
        }

    }
}

线程状态观测

Thread.state 枚举类型

线程状态。线程可以处于下列状态之一：

NEW
至今尚未启动的线程处于这种状态。
RUNNABLE
正在 Java 虚拟机中执行的线程处于这种状态。
BLOCKED
受阻塞并等待某个监视器锁的线程处于这种状态。
WAITING
无限期地等待另一个线程来执行某一特定操作的线程处于这种状态。
TIMED_WAITING
等待另一个线程来执行取决于指定等待时间的操作的线程处于这种状态。
TERMINATED
已退出的线程处于这种状态。

在给定时间点上，一个线程只能处于一种状态。这些状态是虚拟机状态，它们并没有反映所有操作系统线程状态。

package com.LTF.ThreadState;

public class testState {

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

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

        //线程启动
        thread.start();
        state = thread.getState();//更新线程状态
        System.out.println(state);//Runnable

        //线程启动之后
        while (state != Thread.State.TERMINATED){
            //只要线程状态不等于TERMINATED，也就是不终止，就一直输出状态
            Thread.sleep(100);//做个延时，不要输出太快
            state = thread.getState();//状态更新
            System.out.println(state);//状态输出
        }
    }
}

注意：线程状态为：TERMINATED时，意味着线程停止了，停止（死亡）之后的线程是不能再启动的。不管是中断或者是结束，一旦进入死亡状态，就不能再次启动。

线程的优先级（Priority）

Java提供一个线程调度器来监控程序中启动后进入状态的所有线程，线程调度器按照优先级决定应该哪个线程来执行。
线程的优先级用数字表示，范围从1~10
- Thread.MIN_PRIORITY = 1;
- Thread.MAX_PRIORITY = 10;
- Thread.NORM_PRIORITY = 5;
使用以下方式改变或获取优先级
- getPriority().setPriority(int xxx)

优先级建议设定在start()调度前，，，如果在写代码时，觉得哪个线程比较重要，可以设置优先级。

优先级低只是意味着获得调度的概率低，并不是优先级低就不会被调用了，这都是要看CPU调度。

package com.LTF.Thread1.testPriority;

public class TestPriority {
    public static void main(String[] args) {
        //直接输出主线程的优先级为默认优先级5
        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.setPriority(3);
        t1.start();

        t2.setPriority(Thread.MAX_PRIORITY);
        t2.start();

        t3.setPriority(Thread.MIN_PRIORITY);
        t3.start();

        t4.setPriority(Thread.NORM_PRIORITY);
        t4.start();

        t5.start();

        t6.setPriority(9);
        t6.start();
    }

}
class MyPriority implements Runnable{
    @Override
    public void run() {
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName()+"--->"+Thread.currentThread().getPriority());
    }
}

守护（daemon）线程

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

只有一个方法setDaemon()方法，参数为true和false。默认为false。

package com.LTF.Thread1.testDaemon;

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，设置god线程为守护线程。
        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 = 1; i < 35600; i++) {
            System.out.println("这是第"+i+"天，我开心的度过了这一天！！！");
        }
        System.out.println("======GoodBye,World=======");
    }
}

线程同步机制

并发：同一个对象被多个线程同时操作
由于同一进程的多个线程共享同一块存储空间，在带来便利的同时，也带来了访问冲突问题，为了保证数据源在方法中被访问的正确性，在访问时加入锁机制synchronized，当一个线程获得对象的排它锁，独占资源，其它线程必须要等待，使用后释放锁即可，存在以下问题
- 一个线程持有锁会导致其它需要此锁的线程挂起
- 在多线程竞争下，加锁，释放锁会导致比较多的上下文切换和调度延时，引起性能问题
- 如果一个优先级高的线程等待一个优先级低的线程释放锁，会导致优先级倒置，引起性能问题。
虽然解决了线程安全问题，但是损失了性能。

不安全案例

不安全的买票

package com.LTF.SYN;

//不安全的买票
//线程不安全，会出现负数，当票只剩一张时，三个人去拿，会出现负数情况。
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  ticketNum = 10;
    boolean flag = true; //利用标识位，让线程停止
    @Override
    public void run() {
        //1.买票
        while(flag){
            buy();
        }
    }
    //买方法
    public void buy(){
        //判断是否有票
        if(ticketNum <= 0){
            flag = false;
            return;//没有票就返回
        }
        //利用sleep放大事情的发生性
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        //有票就买
        System.out.println(Thread.currentThread().getName()+"拿到了第"+ticketNum--+"张票");
    }
}

不安全的银行账户

package com.LTF.SYN;
//不安全的银行取钱
//出现负数，线程不安全
public class UnsafeBank {
    public static void main(String[] args) {
        Account account = new Account(100,"结婚基金");

        Drawing you  =new Drawing(account,50,"你");
        Drawing girlfriend = new Drawing(account,100,"女朋友");

        you.start();
        girlfriend.start();
    }

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

    //构造方法
    public Account(int money, String name) {
        this.money = money;
        this.name = name;
    }
}

//银行，模拟取款Drawing
class Drawing  extends Thread{
    Account account;//账户
    int drawingmoney; //取的money
    int nowmoney; //手中现有多少钱

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

    @Override
    public void run() {
        //判断账户里是否还够取出money
        if(account.money - drawingmoney < 0){
            System.out.println(Thread.currentThread().getName()+"没钱可取了，你可以放弃了");
            return;
        }
        //利用sleep设置延时
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        //卡内余额= 余额 - 取走的钱
        account.money = account.money -drawingmoney;
        //你手中的钱= 现有的钱 + 取出的钱
        nowmoney = nowmoney + drawingmoney;

        System.out.println(account.name+"余额为："+account.money+"万元");
        //Thread.currentThread().getName() == this.getName()
        System.out.println(this.getName()+"手中现有："+nowmoney+"万元");

    }
}

线程不安全的集合

package com.LTF.SYN;

//不安全的线程的集合

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();
        }
        //线程的条数期待值是会出现10000，但结果却不是，说明线程不安全
        System.out.println(list.size());
    }
}

不安全的原因：可能是两个线程同一时间把两个数组添加到了同一位置，就会覆盖一条，所以说不安全。

同步方法及同步块

由于我们可以通过private 关键字来保证数据对象只能被方法访问，所以我们只需要针对方法提出一套机制，这套机制就是synchronized关键字，它包括两种用法：synchronized方法和synchronized块：
```
同步方法：public synchronized void method(int args){

}
```
synchronized方法控制对“对象”访问，每个对象对应一把锁，每个synchronized方法都必须获取调用该方法对象的锁才能执行，否则线程会阻塞，方法一旦执行，就独占该锁，直到该方法返回才能释放锁，后面被阻塞的线程才能获得这个锁，继续执行。
缺陷：若将一个大的方法声明为synchronized将会影响效率。
同步方法弊端：方法里面需要修改的内容才需要锁，否则锁得太多，浪费资源。

同步块

同步块：synchronized(Obj){ }
Obj 称为 同步监视器
- Obj可以是任何对象，但是推荐使用共享资源作为同步监视器
- 同步方法中无需指定同步监视器，因为同步方法得同步监视器就是this,就是对象本身，或者是class。
同步监视器得执行过程

a. 第一个线程访问，锁定同步监视器，执行其中代码。

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

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

d.第二个线程访问，发现同步监视器没有锁，然后锁定并访问。

例子：如上，不安全的买票

//在线程共同调用的买方法中加入synchronized关键字，将方法变为synchronized同步方法，锁的是this
public synchronized void buy(){
        //判断是否有票
        if(ticketNum <= 0){
            flag = false;
            return;//没有票就返回
        }
        //利用sleep放大事情的发生性
        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        //有票就买
        System.out.println(Thread.currentThread().getName()+"拿到了第"+ticketNum--+"张票");
    }
//最后结果，不会是好几个线程抢一个资源，会一个线程一个资源的往下运行。

如上，不安全的银行账户

//线程共同操作的资源是银行账户这一资源，
//锁的对象就是变化的量，需要增删改的量。
@Override
    public void run() {
        synchronized (account){
            //判断账户里是否还够取出money
            if(account.money - drawingmoney < 0){
                System.out.println(Thread.currentThread().getName()+"没钱可取了，你可以放弃了");
                return;
            }
            //利用sleep设置延时
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            //卡内余额= 余额 - 取走的钱
            account.money = account.money -drawingmoney;
            //你手中的钱= 现有的钱 + 取出的钱
            nowmoney = nowmoney + drawingmoney;

            System.out.println(account.name+"余额为："+account.money+"万元");
            //Thread.currentThread().getName() == this.getName()
            System.out.println(this.getName()+"手中现有："+nowmoney+"万元");

        }
    }

如上，不安全的线程集合

//将list锁起来，线程就安全了，最后结果为10000
for (int i = 0; i < 10000; i++) {
            new Thread(()->{
                synchronized (list){             list.add(Thread.currentThread().getName());
                }
            }).start();
        }

CopyOnWriteArrayList

JUC（Java.util.concurrent）属于并发编程,这是一个处理线程的工具包，JDK1.5开始出现的。

concurrent并发包，callable也是属于这个包中的。

CopyOnWriteArrayList这个类型本身就是安全的，不需要用synchronized来锁

package com.LTF.SYN;
import java.util.concurrent.CopyOnWriteArrayList;

//测试JUC安全类型集合
public class TestJUC {
    public static void main(String[] args) throws InterruptedException {
        CopyOnWriteArrayList<String> list = new CopyOnWriteArrayList<String>();
        for (int i = 0; i < 10000; i++) {
            new Thread( ()->{   list.add(Thread.currentThread().getName()); }).start();
        }
        Thread.sleep(3000);
        System.out.println(list.size());
    }
}

死锁

多个线程各自占有一些共享资源，并且互相等待其它线程占有的资源才能运行，而导致两个或多个线程都在等待对方释放资源，都停止执行的情形。某一个同步块同时拥有“两个以上对象的锁”时，就可能会发生“死锁”的问题。
产生死锁的四个必要条件：
1. 互斥条件：一个资源每次只能被一个进程使用
2. 请求与保持条件：一个进程因请求资源而阻塞时，对于已经获得的资源保持不放。
3. 不剥夺条件：进程已获得的资源，在未使用完之前，不能强行剥夺。
4. 循环等待条件：若干进程之间形成一种头尾相接的循环等待资源关系。
上面列出的死锁的四个必要条件，我们只要想办法破其中的任意一个或者多个条件就可以避免死锁发生。

Lock（锁）

从JDK５.０开始，Java提供了更加强大的线程同步机制——通过显式定义同步锁对象来同步。同步锁使用Lock对象充当。
```
java.util.concurrent.locks.Lock
```
接口是控制多个线程对共享资源进行访问的工具。锁提供了对共享资源的独占访问，每次只能有一个线程对Lock对象加锁，线程开始访问共享资源之前应先获得Lock对象。

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

//一般使用try/catch来加锁和释放锁
class A{
    private final ReentrantLock lock = new ReenTrantLock();
    public void m(){
        try{
          lock.lock(); //加锁
            //保证线程安全的代码
        }finally{
            lock.unlock();
            //如果同步代码有异常，要将unlock()写入finally语句块中
        }
    }
}

synchronized与Lock的对比

Lock是显示锁（手动开启和关闭锁，别忘记关闭锁）synchronized是隐式锁，出了作用域自动释放。
Lock只有代码块锁，synchronized有代码块和方法锁
使用Lock锁，JVM将花费较少的时间来调度线程，性能更好。并且具有更好的扩展性（提供更多的子类）
优先使用顺序：

Lock > 同步代码块（进入了方法体，分配了响应的资源）> 同步方法（在方法体之外）

线程协作

生产者消费者问题

利用管程法解决生产者与消费者问题，并发协作模型“生产者/消费者模式”

生产者：负责生产数据的模块（可能是方法，对象，线程，进程）；

消费者：负责处理数据的模块（可能是方法，对象，线程，进程）；

缓冲区：消费者不能直接使用生产者的数据，它们之间有一个缓冲区，生产者将生产好的数据放入缓冲区，消费者从缓冲区中拿出数据。

例子：

package com.LTF.SYN;

//测试：生产者和消费者模型---》用缓冲区解决，管程法
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 = 1; 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 = 1; 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){
        //如果容器已满，就需要先等待消费者消费
        while(count == chickens.length){
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        //如果没有满我们就继续放入产品
        chickens[count] =chicken;
        System.out.println("该缓冲区中已有"+count+"只鸡");
        count++;

        //可以通知消费者消费了
        this.notify();
    }

    //消费者消费产品
    public synchronized Chicken pop(){

        //判断是否能够消费
        while (count == 0) {
            //不能消费时（实际数量为0） 消费者等待 生产
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        //如果有产品
        count--;
        Chicken chicken = chickens[count];
        //消费者取走一件产品后，
        // 通知生产者继续生产放入缓冲区
        this.notify();
        return chicken;
    }
}

线程池

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

package com.LTF.SYN;

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

//测试线程池
public class TestPool {
    public static void main(String[] args) {
        //创建服务，创建线程池
        //newFixedThreadPool 参数为：线程池大小
        ExecutorService service = Executors.newFixedThreadPool(10);

        //执行
        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());
    }
}


消费者取走一件产品后，
        // 通知生产者继续生产放入缓冲区
        this.notify();
        return chicken;
    }
}

线程池

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

package com.LTF.SYN;

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

//测试线程池
public class TestPool {
    public static void main(String[] args) {
        //创建服务，创建线程池
        //newFixedThreadPool 参数为：线程池大小
        ExecutorService service = Executors.newFixedThreadPool(10);

        //执行
        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());
    }
}

Java多线程学习笔记