Java并发编程基础

_幻化成风_

已于 2022-07-15 21:41:03 修改

阅读量333

点赞数

分类专栏： Java并发编码总结文章标签： java 多线程

于 2021-02-13 00:39:03 首次发布

本文链接：https://blog.csdn.net/m0_37929837/article/details/113483139

版权

Java并发编码总结专栏收录该内容

3 篇文章 0 订阅

订阅专栏

普通方法调用和多线程区别

程序，进程-process，线程-Thread

缓冲队列BlockingQueue和自定义线程池ThreadPoolExecutor

普通方法调用和多线程区别

程序，进程-process，线程-Thread

在操作系统中运行的程序就是进程，比如QQ，播放器，游戏，IDE等，一个进程可以有多个线程，比如视频中同时听声音，看图像，看弹幕等等。

程序是指令和数据的有序集合，其本身没有任何运行的含义，是一个静态的概念；

进程则是执行程序的一次执行过程，它是一个动态的概念，是系统资源分配的单位；一个进程至少有一个线程，不然没有存在的意义；

线程是CPU调度和执行的单位。

注意：很多多线程是模拟出来的，真正的多线程是指有多个cpu，即多核，如服务器。如果是模拟出来的多线程，即在一个cpu的情况下，在同一个时间点，cpu只能执行一个代码，因为切换的很快，所以就有同时执行的错觉。线程之间切换是因为每个线程都有一个时间片，时间片到期就会cpu被另一个线程抢占使用，也就是cpu允许一个线程运行多长时间，单位好像是纳秒。

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

创建线程方式一：继承Thread类

创建线程方式：继承Thread类，重写run()方法，调用start开启线程
总结：注意，线程开启不一定立即执行，由cpu调度执行

public class Demo1 extends Thread{

    public void run(){
        //run方法线程体
        for (int i = 0; i < 20; i++) {
            System.out.println("我是run方法"+i);
        }
    }

    public static void main(String[] args) {
        //创建一个线程对象
        Demo1 demo1 = new Demo1();
        //调用start()方法开启线程
        demo1.start();

        //main线程，主线程
        for (int i = 0; i < 1000; i++) {
            System.out.println("我是主线程"+i);
        }
    }

}
//结果其中一块是这样，因为由于单核cpu，所以线程是交替执行的，线程在争抢时间片
/*
我是run方法2
我是主线程32
我是主线程33
我是主线程34
我是主线程35
我是run方法3
我是run方法4
我是run方法5
我是主线程36
 */

继续，如果按照下方的多线程写法呢，同时执行这个类里的方法。

public class Demo1 extends Thread{
    private String name;
    public Demo1(String name){
        this.name=name;
    }
    public void run(){
        //run方法线程体
        System.out.println(name);
    }
    public static void main(String[] args) {
        Demo1 demo1 = new Demo1("1");
        Demo1 demo2 = new Demo1("2");
        Demo1 demo3 = new Demo1("3");
        demo1.start();
        demo2.start();
        demo3.start();
    }
}
/*
1
3
2
 */

每次结果都不唯一，很明显，也没有按照预计的要求顺序输出，说明是同步执行。

创建线程方式二：实现Runnable接口

代理：就是你把东西给我，我帮你执行

public class Demo2 implements Runnable{
    public void run(){
        //run方法线程体
        for (int i = 0; i < 5; i++) {
            System.out.println("线程编号"+i);
        }
    }

    public static void main(String[] args) {
        //创建runnable接口的实现类对象
        Demo2 demo2 = new Demo2();
        //创建线程对象，通过线程对象来开启我们的线程，这就是线程代理
        new Thread(demo2).start();   //把对象代理给线程使用
        for (int i = 0; i < 10; i++) {
            System.out.println("主线程编号"+i);
        }
    }
}

总结：

继承Thread类

子类继承Thread类具备多线程能力
启动线程：子类对象.start()
不建议使用：避免OOP单继承局限性，因为如果继承了Thread类就不允许继承其他类了

实现Runnable接口

实现接口Runnable具有多线程能力
启动线程：传如目标对象+Thread对象.start()
推荐使用：避免单继承局限性，灵活方便，方便同一个对象被多个线程使用，解释下，比如下方代理，创建了一个对象，然后交给三个线程来处理，同时跑一个对象，这就是实现Runnable接口的好处。

StartThread st=new StartThread(); //一份资源
new Thread(st,"小明").start();
new Thread(st,"小黑").start(); //多个代理，st后面的是线程的名字
new Thread(st,"小白").start();

初识并发问题

多个线程抢票，创造一个并发问题

多个线程同时操作同一个对象，线程不安全，数据紊乱，如下方输出结果5，6两个票被多个人同时拿到，这就是并发问题。

public class Demo3 implements Runnable{
    private int ticketnums=10;
    public void run(){
        while (true){
            if(ticketnums==0){
                break;
            }
            //模拟延时，放置cpu执行过快看不到超卖现象
            try {
                Thread.sleep(200);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName()+"抢了第"+ticketnums--+"个票");
        }
    }

    public static void main(String[] args) {
        Demo3 demo3 = new Demo3();
        new Thread(demo3,"小明").start();
        new Thread(demo3,"小白").start();
        new Thread(demo3,"黄牛").start();
    }
}

/*
小白抢了第10个票
黄牛抢了第9个票
小明抢了第8个票
小白抢了第6个票
小明抢了第7个票
黄牛抢了第6个票
小明抢了第5个票
黄牛抢了第4个票
小白抢了第5个票
黄牛抢了第3个票
小白抢了第2个票
小明抢了第1个票
 */

模拟龟兔赛跑，这里不让兔子休眠了

//模拟龟兔赛跑
public class Race implements Runnable{
    //定义比赛跑到长100米
    public static String winnder;
    public void run(){
        for (int i = 0; i <= 100 ; i++) {
            System.out.println(Thread.currentThread().getName()+"跑了"+i+"步");
            boolean over = getWinnder(i);
            if (over){   //为true比賽結束
                break;
            }
        }
    }

    //判断比赛是否结束并输出赢家
    public boolean getWinnder(int steps){

        if(steps==100){
            winnder=Thread.currentThread().getName();
            System.out.println("胜利者是"+winnder);
            return true;
        }
        return false;
    }

    public static void main(String[] args) {
        Race race = new Race();
        new Thread(race,"兔子").start();
        new Thread(race,"乌龟").start();
    }

}

Lambda表达式

new Thread( ()-> System.out.println("Hello world") ).start();

为什么要使用lambda表达式

避免匿名内部类定义过多
可以让你的代码看起来很简洁
去掉了一堆没有意义的代码，只留下核心的逻辑

理解Functional Interface(函数式接口)是学习Java8 lambda表达式的关键所在

函数式接口的定义：接口里的方法默认是抽象的，是public abstract修饰的，如果只包含唯一一个抽象方法，那么它就是一个函数式接口。

例如：public interface Runnable{
void run(); //只有一个方法
}

对于函数式接口，可以通过lambda表达式来创建该接口的对象，说白了就是为了简化一个实现类，不用再定义内部类了。

public class Lambda {
    public static void main(String[] args) {
//        ILike like = new Like();
//        like.lambda();
        
        ILike like;

        //匿名内部类，没有类的名称，必须借助接口或者父类
        like = new ILike(){
            @Override
            public void lambda() {
                System.out.println("I like lambda2");
            }
        };
        like.lambda();

        //使用lambda方式实现，根本不需要再去定义一个外部类或者匿名内部类
        like= () -> {
            System.out.println("I like lambda3");
        };
        like.lambda();
    }

}

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

class Like implements ILike{
    @Override
    public void lambda() {
        System.out.println("I like lambda");
    }
}

在来一例有参数的，Lambda表达式只有在只有一行代码的情况下才能简化成一行代码，多行就用{}包裹。

public class Application {

    public static void main(String[] args) {
        ILove iLove;
        iLove = (int a) -> {
            System.out.println("I love you "+a+"天");
            System.out.println("I love you "+a+"天");
        };
        iLove.love(520);

        //简化
        iLove=(a) -> {
            System.out.println(("I love you "+a+"天"));
        };
        iLove.love(521);

        //再简化
        iLove=a -> {
            System.out.println(("I love you "+a+"天"));
        };
        iLove.love(522);

        //最后一次简化
        iLove=a -> System.out.println(("I love you "+a+"天"));
        iLove.love(523);
    }

    interface ILove{
        void love(int a);
    }
}

线程五种状态

创建状态——就绪状态——阻塞状态——运行状态——死亡状态

Thread t=new Thread()，线程对象一旦创建就进入到了新生状态
当调用start()方法，线程立即进入就绪状态，但不意味着立即调度执行
进入运行状态，线程才真正执行线程体的代码块
当调用sleep，wait或同步锁定时，线程进入阻塞状态，就是代码不往下执行，阻塞事件解除后，重新进入就绪状态，等待cpu调度执行
线程中断或者结束，一旦进入死亡状态，就不能再次启动

停止线程

不推荐使用JDK提供的stop()、destroy()方法。【已废弃】
推荐线程自己停止下来
建议使用一个标志位进行终止变量，当flag=false，则终止线程运行。

public class Demo4 implements Runnable{

    private boolean flag = true;  //设置一个标志位

    @Override
    public void run() {
        int i=0;
        while (flag){
            System.out.println("run...Thread"+i++);
        }
    }

    //自定义一个公开的方法停止线程，转换标志位
    public void stop(){
        this.flag=false;
    }

    public static void main(String[] args) {
        Demo4 demo4 = new Demo4();
        new Thread(demo4).start();
        for (int i = 0; i < 1000; i++) {   //快捷键：1000.fori
            System.out.println("主线程"+i);
            if (i==900){
                demo4.stop();   //调用stop方法切换标志位，让线程停止
                System.out.println("线程该停止了");
            }
        }
    }
}

线程休眠

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

//模拟倒计时
public class Demo5 {

    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;
            }
        }
    }
}

线程等待--wait

wait()的作用是让当前线程进入等待状态，同时，wait()也会让当前线程释放它所持有的锁。“直到其他线程调用此对象的 notify() 方法或 notifyAll() 方法”，当前线程被唤醒(进入“就绪状态”)

wait(long timeout)让当前线程处于“等待(阻塞)状态”，“直到其他线程调用此对象的notify()方法或 notifyAll() 方法，或者超过指定的时间量”，当前线程被唤醒(进入“就绪状态”)。

notify()和notifyAll()的作用，则是唤醒当前对象上的等待线程；notify()是唤醒单个线程，而notifyAll()是唤醒所有的线程。

wait必须用在同步代码块里.

// main（主线程）
synchronized(t1) {
try {
t1.start();
t1.wait();
} catch(InterruptedException e) {
e.printStackTrace();
}
}

// 在 t1 线程中唤醒主线程
synchronized (this) { //这里的 this 为 t1
this.notify();
}

线程礼让---yield

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

public class Demo6 {

    public static void main(String[] args) {
        MyYield myYield = new MyYield();
        new Thread(myYield,"小明").start();
        new Thread(myYield,"小黑").start();
    }

    static class MyYield implements Runnable{
        @Override
        public void run() {
            System.out.println(Thread.currentThread().getName()+"线程开始执行");
            Thread.yield();  //礼让，但不一定成功
            System.out.println(Thread.currentThread().getName()+"线程执行结束");
        }
    }
}
/* 
礼让成功的输出：
小黑线程开始执行
小明线程开始执行
小黑线程执行结束
小明线程执行结束

礼让失败的输出：
小明线程开始执行
小明线程执行结束
小黑线程开始执行
小黑线程执行结束
 */

线程强制执行----join

join合并线程，待此线程执行完成后，再执行其他线程，其他线程阻塞
可以想象成插队

如下，结果当i=50的时候会阻塞主线程，然后执行插队的线程，插队线程执行完毕后再执行主线程

public class Demo7 implements Runnable {

    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.println("我是来插队的"+i);
        }
    }

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

        for (int i = 0; i < 100; i++) {
            if (i == 50) {
                thread.join();
            }
            System.out.println("我是主线程" + i);
        }
    }
}

/*
我是主线程49
我是来插队的0
我是来插队的1
我是来插队的2
.....
我是来插队的99
我是主线程50
 */

观测线程状态

Thread.State state = thread.getState();
System.out.println(state);

public class Demo8 {

    public static void main(String[] args) throws InterruptedException {
        Thread thread=new Thread(()->{
            for (int i = 0; i < 5; i++) {  //先睡5秒
                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); //输出状态
        }
    }
}

线程的优先级---priority

Java提供一个线程调度器来监控程序中启动后进入就绪状态的所有线程，线程调度器按照优先级决定应该调度哪个线程来执行。但是优先级高的不一定先执行，大多数情况下会先执行，与那个线程礼让yield一样的道理。优先级默认是5。优先级低只是意味着获得调度的概率低.并不是优先级低就不会被调用了.这都是看CPU的调度。

线程的优先级用数字表示，范围从1~10.

Thread.MIN_ PRIORITY = 1;
Thread.MAX_ PRIORITY= 10;
Thread.NORM_ PRIORITY = 5;

使用以下方式改变或获取优先级 getPriority() ，setPriority(int xxx)

public class Demo9 {
    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);

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

        t2.setPriority(Thread.MIN_PRIORITY);  //优先级最低，为1
        t2.start();

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

        t4.setPriority(Thread.MAX_PRIORITY);  //优先级最高，为10
        t4.start();

//        t5.setPriority(-1);   //不可为负数，会报错
//        t5.start();
    }
}

class MyPriority implements Runnable{
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName()+"子线程优先级"+Thread.currentThread().getPriority());
    }
}

/*
main主线程优先级5
Thread-3子线程优先级10
Thread-0子线程优先级5
Thread-2子线程优先级4
Thread-1子线程优先级1
 */

守护线程---daemon

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

用个比较通俗的比如，任何一个守护线程都是整个JVM中所有非守护线程的保姆：

只要当前JVM实例中尚存在任何一个非守护线程没有结束，守护线程就全部工作；只有当最后一个非守护线程结束时，守护线程随着JVM一同结束工作。
Daemon的作用是为其他线程的运行提供便利服务，守护线程最典型的应用就是 GC (垃圾回收器)，它就是一个很称职的守护者。

User和Daemon两者几乎没有区别，唯一的不同之处就在于虚拟机的离开：如果 User Thread已经全部退出运行了，只剩下Daemon Thread存在了，虚拟机也就退出了。因为没有了被守护者，Daemon也就没有工作可做了，也就没有继续运行程序的必要了。

下方代码执行结果说明了在用户线程执行完毕后，到JVM关闭的时候，这段时间守护线程还会跑一会才结束。

public class Demo10 {
    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();  //守护线程启动
        /*
        上帝守护线程启动，注意 thread.setDaemon(true)必须在thread.start()之前设置，
        否则会跑出一个IllegalThreadStateException异常。
        因为你不能把正在运行的常规线程设置为守护线程。
        */
        
        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!===");
    }
}

这里有几点需要注意：

(1) thread.setDaemon(true)必须在thread.start()之前设置，否则会跑出一个IllegalThreadStateException异常。你不能把正在运行的常规线程设置为守护线程。
(2) 在Daemon线程中产生的新线程也是Daemon的。
(3) 不要认为所有的应用都可以分配给Daemon来进行服务，比如读写操作或者计算逻辑。

因为你不可能知道在所有的User完成之前，Daemon是否已经完成了预期的服务任务。一旦User退出了，可能大量数据还没有来得及读入或写出，计算任务也可能多次运行结果不一样。这对程序是毁灭性的。造成这个结果理由已经说过了：一旦所有User Thread离开了，虚拟机也就退出运行了。

线程同步机制

多个线程操作一个资源，即并发，线程同步需要队列+锁这两个东西来解决线程不安全问题。

要保证安全就会牺牲部分性能，要保证性能就要牺牲部分安全。所谓鱼与熊掌不可兼得就是这个道理。

处理多线程问题时，多个线程访问同一一个对象，并且某些线程还想修改这个对象。这时候我们就需要线程同步。
线程同步其实就是一种等待机制，多个需要同时访问此对象的线程进入这个对象的等待池形成队列,等待前面线程使用完毕，下一个线程再使用。

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

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

三大线程不安全案例

1）不安全的买票

public class Demo1 {
    public static void main(String[] args) {
        BuyTickets buyTickets = new BuyTickets();
        new Thread(buyTickets,"我").start();
        new Thread(buyTickets,"你们").start();
        new Thread(buyTickets,"黄牛").start();
    }
}

class BuyTickets implements Runnable{

    private int ticketName=10;
    boolean flag = true;
    @Override
    public void run() {
        //买票
        while (flag){
            try {
                buy();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

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

2）两个人去银行取钱

public class Demo2 {
    public static void main(String[] args) {
        //账户
        Account account = new Account(100,"结婚基金");
        Drawing you = new Drawing(account,50,"自己");
        Drawing wife = new Drawing(account,100,"老婆");
        new Thread(you).start();
        new Thread(wife).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);  //调用父类Thread的name
        this.account = account;
        this.drawingMoney = drawingMoney;
    }

    // 取钱
    public void run(){
        //判断有没有钱
        if(account.money-drawingMoney<0){
            System.out.println(Thread.currentThread().getName()+"钱不够，取不了");
            return;
        }
        try {  //休眠有助于放大问题
            Thread.sleep(100);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        //卡内余额=余额-取出的钱
        account.money=account.money-drawingMoney;
        //去除的钱
        nowMoney=nowMoney+drawingMoney;
        System.out.println(account.name+"余额为"+account.money);
        /*由于这里继承了Thread，所以可以直接用this.getName()
        等价于Thread.currentThread().getName()
         */
        System.out.println(this.getName()+"手里钱为"+nowMoney);
    }
}

3）线程不安全集合

public class Demo3 {
    public static void main(String[] args) throws InterruptedException {
        List<String> list = new ArrayList<String>();
        for (int i = 0; i < 10000; i++) {
            new Thread(
                ()->{
                    list.add(Thread.currentThread().getName());
                }
            ).start();
        }
        Thread.sleep(3000);   //睡眠三秒，让一万个线程有足够的时间加到集合里
        System.out.println(list.size());
    }
}

同步方法及同步块

◆由于我们可以通过private关键字来保证数据对象只能被方法访问,所以我们只需要针对方法提出一套机制,这套机制就是synchronized关键字,它包括两种用法:synchronized方法和synchronized块.

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

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

缺陷:若将一个大的方法申明为synchronized将会影响效率。

方法里面需要修改的内容才需要锁，锁的太多，浪费资源。

同步块: synchronized (Obj){}

Obj称之为同步监视器
◆Obj可以是任何对象,但是推荐使用共享资源作为同步监视器
◆同步方法中无需指定同步监视器,因为同步方法的同步监视器就是this ,就是这个对象本身,或者是class

同步监视器的执行过程
1. 第一个线程访问,锁定同步监视器,执行其中代码
2.第二个线程访问 ,发现同步监视器被锁定,无法访问
3.第一个线程访问完毕,解锁同步监视器
4.第二个线程访问，发现同步监视器没有锁,然后锁定并访问

使用synchronize来修改三大线程不安全案例里的买票，只需在buy方法里加个关键字synchronized，相当于修饰符

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

使用使用synchronize来修改三大线程不安全案例里的取钱，这个要用同步块

默认锁的是this，即synchronized(this)，this表示这个对象，这个类，也就是Drawing银行这个类，所以没有作用，锁的东西取决于进程同时执行的对象（变化的），锁的对象是唯一的。

public void run(){
    //锁的对象得是变化的量，就是增删改的量
    synchronized (account){
        //判断有没有钱
        if(account.money-drawingMoney<0){
            System.out.println(Thread.currentThread().getName()+"钱不够，取不了");
            return;
        }
        try {  //休眠有助于放大问题
            Thread.sleep(100);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        //卡内余额=余额-取出的钱
        account.money=account.money-drawingMoney;
        //去除的钱
        nowMoney=nowMoney+drawingMoney;
        System.out.println(account.name+"余额为"+account.money);
    /*由于这里继承了Thread，所以可以直接用this.getName()
    等价于Thread.currentThread().getName()
     */
        System.out.println(this.getName()+"手里钱为"+nowMoney);
    }
}

public class Demo3 {
    public static void main(String[] args) throws InterruptedException {
        List<String> list = new ArrayList<String>();
        for (int i = 0; i < 10000; i++) {

            new Thread(
                ()->{
                    synchronized (list){  //锁住list集合
                        list.add(Thread.currentThread().getName());
                    }
                }
            ).start();
        }
        Thread.sleep(3000);
        System.out.println(list.size());
    }
}

CopyOnWriteArrayList

CopyOnWriteArrayList使用了一种叫写时复制的方法，

当有新元素添加到CopyOnWriteArrayList时，
先从原有的数组中拷贝一份出来，然后在新的数组做写操作，
写完之后，再将原来的数组引用指向到新数组。
- 创建新数组，并往新数组中加入一个新元素,这个时候，array这个引用仍然是指向原数组的。
- 当元素在新数组添加成功后，将array这个引用指向新数组。
CopyOnWriteArrayList的整个add操作都是在锁的保护下进行的。
- 这样做是为了避免在多线程并发add的时候，
- 复制出多个副本出来,把数据搞乱了，导致最终的数组数据不是我们期望的。

add源码如下：

public boolean add(E e) {
        final ReentrantLock lock = this.lock;
        lock.lock();
        try {
            Object[] elements = getArray();
            int len = elements.length;
            Object[] newElements = Arrays.copyOf(elements, len + 1);
            newElements[len] = e;
            setArray(newElements);
            return true;
        } finally {
            lock.unlock();
        }
    }

JUC就是java.util .concurrent工具包的简称。这是一个处理线程的工具包，JDK 1.5开始出现的。juc下的包非常多，举个CopyOnWriteArrayList例子

测试JUC安全类型的集合

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

死锁

多个线程各自占有一-些共享资源 ,并且互相等待其他线程占有的资源才能运行,而导致两个或者多个线程都在等待对方释放资源,都停止执行的情形. 某一个同步块同时拥有“两个以上对象的锁”时,就可能会发生“死锁”的问题.

产生死锁的必要条件：

互斥条件：进程要求对所分配的资源进行排它性控制，即在一段时间内某资源仅为一进程所占用。
请求和保持条件：当进程因请求资源而阻塞时，对已获得的资源保持不放。
不剥夺条件：进程已获得的资源在未使用完之前，不能剥夺，只能在使用完时由自己释放。
环路等待条件：在发生死锁时，必然存在一个进程--资源的环形链。

任何线程进入同步代码块、同步方法之前，必须获得同步监视器的锁定，那么何时会释放这个锁定呢？在程序中，是无法显式释放对同步监视器的锁的，而会在如下几个情况下释放锁。

1、当前线程的同步方法、代码块执行结束的时候释放

2、当前线程在同步方法、同步代码块中遇到break 、 return 终于该代码块或者方法的时候释放。

3、出现未处理的error或者exception导致异常结束的时候释放

4、程序执行了 同步对象 wait 方法，当前线程暂停，释放锁

如下情况不会释放锁

1、程序调用 Thread.sleep() Thread.yield() 这些方法暂停线程的执行，不会释放。

2、线程执行同步代码块时，其他线程调用 suspend 方法将该线程挂起，该线程不会释放锁，所以我们应该避免使用 suspend 和 resume 来控制线程。

死锁代码示例，两个线程是同步进行的，第一个线程先获得t1，然后停一毫秒，目的是为了让第二个线程有时间拿到t2对象，防止cpu把两个对象都只分配给其中一个线程。然后第一个线程继续执行里面的代码块，即要获得t2对象，此时由于获取t2的代码块写在synchronized (t1){}里面，所以t1对象并没有释放，因为里面的代码块没有执行结束。
同理第二个线程先获得t2对象，然后sleep要获取t1对象，由于t1对象仍然在第一个线程的手里没有释放，不可能拿到，t2对象又不可能被第一个线程拿到，所以两边相互等待，成了死锁。

public class DieLock {

    public static Object t1 = new Object();
    public static Object t2 = new Object();

    public static void main(String[] args){
        new Thread(){
            @Override
            public void run(){
                synchronized (t1){
                    System.out.println("Thread1 get t1");
                    try {
                        Thread.sleep(100);
                    }catch (Exception e){

                    }

                    synchronized (t2){
                        System.out.println("Thread2 get t2");
                    }
                }
            }
        }.start();

        new Thread(){
            @Override
            public void run(){
                synchronized (t2){
                    System.out.println("Thread2 get t2");

                    try {
                        Thread.sleep(100);
                    }catch (Exception e){

                    }

                    synchronized (t1){
                        System.out.println("Thread2 get t1");
                    }
                }
            }
        }.start();
    }
}

Lock锁

从JDK 5.0开始，Java提供了更强大的线程同步机制一通过显式定义同步锁对象来实现同步。同步锁使用Lock对象充当java.util.concurrent.locks.Lock接口是控制多个线程对共享资源进行访问的工具。锁提供了对共享资源的独占访问，每次只能有一个线程对Lock对象加锁，线程开始访问共享资源之前应先获得Lock对象ReentrantLock类实现了Lock，它拥有与synchronized相同的并发性和内存语义，在实现线程安全的控制中，比较常用的是Reentrantlock,可以显式加锁、释放锁。作用与synchronized一致。

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

synchronized与Lock的对比

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

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){
            //在这个if代码块加锁
            try {
                lock.lock(); //加锁，一般要用try-finally包围起来，因为涉及到手动解锁

                //代码块开始
                if(ticketNums>0){
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread().getName()+"："+ticketNums--);
                }else{
                    break;
                }
                //代码块结束

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

生产者消费者问题

应用场景:生产者和消费者问题

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

线程通信分析
这是一个线程同步问题,生产者和消费者共享同-个资源,并且生产者和消费者之间相互依赖,互为条件.

对于生产者,没有生产产品之前,要通知消费者等待.而生产了产品之后,又需要马上通知消费者消费
对于消费者, 在消费之后,要通知生产者已经结束消费,需要生产新的产品以供消费.
synchronized 可阻止并发更新同一个共享资源，实现了同步
synchronized不能用来实现不同线程之间的消息传递(通信)

Java提供了几个方法解决线程之间的通信问题

注意:均是Object类的方法，都只能在同步方法或者同步代码块中使用,否则会抛出异常legalMonitorStateException

管程法

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

生产者:负责生产数据的模块(可能是方法,对象,线程,进程);
消费者:负责处理数据的模块(可能是方法,对象,线程,进程);
缓冲区：消费者不能直接使用生产者的数据，他们之间有个缓冲区，生产者将生产好的数据放入缓冲区，消费者从缓冲区拿出数据

思路:

1.首先有一个生产者，消费者、生产者只顾生产，消费者只管消费、

2.利用了一个缓冲区，缓冲了一个10个大小的数组

3.有个方法叫放入产品，产品丢进来的时候，我们判断一下缓冲区有没有满，如果满了的话，生产者就要等待了，

如果没有满，就将产品放进去，放进去之后有产品了，赶紧通知消费者消费

4.消费者就判断下能不能消费呢，有没有东西，有东西的话，我就可以直接消费，消费完了，就赶紧通知生产者生产。

如果没有东西呢，消费者就等待。等待生产者去通知他，生产者通知了，他就可以解除等待了。

public class guancheng {
    //生产者消费者模式，主要是用来借助一个缓冲区，管程法.
    public static void main(String[] args) {
        huanchong hc =new huanchong();
        new shengchan(hc).start();
        new xiaofei(hc).start();
    }
}
class shengchan extends Thread{
    huanchong hc;
    public shengchan(huanchong hc) {
        this.hc =hc;
    }
    public void run() {
        for(int i=0; i<10; i++) {
            System.out.println("生产了"+i+"个馒头");
            hc.push(new mantou(i));
        }
    }
}
class xiaofei extends Thread{
    huanchong hc;
    public xiaofei(huanchong hc) {
        this.hc =hc;
    }
    public void run() {
        for(int i=0; i<100; i++) {
            System.out.println("消费了"+hc.pop().id+"个馒头");
        }
    }
}
class huanchong{
    mantou[] mt =new mantou[10];
    int count=0;
    //存取
    public synchronized void push(mantou m) {
        if(count==mt.length) {
            try {
                this.wait();
            } catch (InterruptedException e) {
            }
        }
        mt[count++]=m;
        //有了空间之后。通知消费者消费
        this.notifyAll();
    }
    //消费
    public synchronized mantou pop() {
        if(count==0) {
            try {
                this.wait();
            } catch (InterruptedException e) {
            }
        }
        count--;
        mantou m=mt[count];
        //没有空间，通知生产者生产
        this.notifyAll();
        return m;
    }
}
class mantou{
    int id;
    public mantou(int id) {
        this.id=id;
    }
}

信号灯法

来判断一个标志位flag，如果为true，就让他等待、如果为false，就让他去通知另外一个人、把两人衔接起来，就像咱们的信号灯红灯停，绿灯行，通过这样一个判断方式，只要来判断什么时候让他等待，什么时候将他唤醒即可。

package com.thread.gaoji;

//测试生产者消费者问题2：信号灯法，通过标志位解决

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) {
                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.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;
    }
}

线程池

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

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

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

1. 线程池的概念：
线程池就是首先创建一些线程，它们的集合称为线程池。使用线程池可以很好地提高性能，线程池在系统启动时即创建大量空闲的线程，程序将一个任务传给线程池，线程池就会启动一条线程来执行这个任务，执行结束以后，该线程并不会死亡，而是再次返回线程池中成为空闲状态，等待执行下一个任务。

2. 线程池的工作机制
2.1 在线程池的编程模式下，任务是提交给整个线程池，而不是直接提交给某个线程，线程池在拿到任务后，就在内部寻找是否有空闲的线程，如果有，则将任务交给某个空闲的线程。
2.1 一个线程同时只能执行一个任务，但可以同时向一个线程池提交多个任务。

3. 使用线程池的原因：
多线程运行时间，系统不断的启动和关闭新线程，成本非常高，会过渡消耗系统资源，以及过渡切换线程的危险，从而可能导致系统资源的崩溃。这时，线程池就是最好的选择了。

四种线程池介绍

1. 线程池的返回值ExecutorService简介：ExecutorService是Java提供的用于管理线程池的类。该类的两个作用：控制线程数量和重用线程。
2. 具体的4种常用的线程池实现如下：（返回值都是ExecutorService）

1）Executors.newCacheThreadPool()：可缓存线程池，先查看池中有没有以前建立的线程，如果有，就直接使用。如果没有，就建一个新的线程加入池中，缓存型池子通常用于执行一些生存期很短的异步型任务，线程池为无限大，当执行当前任务时上一个任务已经完成，会复用执行上一个任务的线程，而不用每次新建线程。代码例如

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

public class NewCachedThreadPoolTest {

    public static void main(String[] args) {
        // 创建一个可缓存线程池
        ExecutorService cachedThreadPool = Executors.newCachedThreadPool();
        for (int i = 0; i < 10; i++) {
            try {
                // sleep可明显看到使用的是线程池里面以前的线程，没有创建新的线程
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            cachedThreadPool.execute(new Runnable() {
                public void run() {
                    // 打印正在执行的缓存线程信息
                    System.out.println(Thread.currentThread().getName()
                            + "正在被执行");
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            });
        }
    }
}

2）Executors.newFixedThreadPool(int n)：创建一个可重用固定个数的线程池，以共享的无界队列方式来运行这些线程。定长线程池的大小最好根据系统资源进行设置。如Runtime.getRuntime().availableProcessors()，代码例如

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

public class NewFixedThreadPoolTest {

    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());
        System.out.println(Runtime.getRuntime().availableProcessors());
        //2.关闭连接
        service.shutdown();
    }
}

class MyThread implements Runnable{
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName());
    }
}

3）Executors.newScheduledThreadPool(int n)：创建一个定长线程池，支持定时及周期性任务执行

import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;

public class NewScheduledThreadPoolTest {

    public static void main(String[] args) {
        //创建一个定长线程池，支持定时及周期性任务执行——延迟执行
        ScheduledExecutorService scheduledThreadPool = Executors.newScheduledThreadPool(5);
        //延迟1秒执行
                 /*scheduledThreadPool.schedule(new Runnable() {
                     public void run() {
                        System.out.println("延迟1秒执行");
                     }
                 }, 1, TimeUnit.SECONDS);*/
                 
        //延迟1秒后每3秒执行一次
        scheduledThreadPool.scheduleAtFixedRate(new Runnable() {
            public void run() {
                System.out.println("延迟1秒后每3秒执行一次");
            }
        }, 1, 3, TimeUnit.SECONDS);

    }
}

4）Executors.newSingleThreadExecutor()：创建一个单线程化的线程池，它只会用唯一的工作线程来执行任务，保证所有任务按照指定顺序(FIFO, LIFO, 优先级)执行。

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

public class NewSingleThreadExecutorTest {

    public static void main(String[] args) {
        //创建一个单线程化的线程池
        ExecutorService singleThreadExecutor = Executors.newSingleThreadExecutor();
        for (int i = 0; i < 10; i++) {
            final int index = i;
            singleThreadExecutor.execute(new Runnable() {
                public void run() {
                    try {
                        //结果依次输出，相当于顺序执行各个任务
                        System.out.println(Thread.currentThread().getName()+"正在被执行,打印的值是:"+index);
                        Thread.sleep(5000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            });
        }
    }
}

缓冲队列BlockingQueue和自定义线程池ThreadPoolExecutor

1. 缓冲队列BlockingQueue简介：

BlockingQueue是双缓冲队列。BlockingQueue内部使用两条队列，允许两个线程同时向队列一个存储，一个取出操作。在保证并发安全的同时，提高了队列的存取效率。

2. 常用的几种BlockingQueue：

ArrayBlockingQueue（int i）:规定大小的BlockingQueue，其构造必须指定大小。其所含的对象是FIFO顺序排序的。
LinkedBlockingQueue（）或者（int i）:大小不固定的BlockingQueue，若其构造时指定大小，生成的BlockingQueue有大小限制，不指定大小，其大小有Integer.MAX_VALUE来决定。其所含的对象是FIFO顺序排序的。
PriorityBlockingQueue（）或者（int i）:类似于LinkedBlockingQueue，但是其所含对象的排序不是FIFO，而是依据对象的自然顺序或者构造函数的Comparator决定。
SynchronizedQueue（）:特殊的BlockingQueue，对其的操作必须是放和取交替完成。

3. 自定义线程池（ThreadPoolExecutor和BlockingQueue连用）：

自定义线程池，可以用ThreadPoolExecutor类创建，它有多个构造方法来创建线程池。

常见的构造函数：ThreadPoolExecutor(int corePoolSize, int maximumPoolSize, long keepAliveTime, TimeUnit unit, BlockingQueue<Runnable> workQueue)

import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

public class ZiDingYiThreadPoolExecutor {

    static class TempThread implements Runnable {

        @Override
        public void run() {
            // 打印正在执行的缓存线程信息
            System.out.println(Thread.currentThread().getName() + "正在被执行");
            try {
                // sleep一秒保证3个任务在分别在3个线程上执行
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    public static void main(String[] args) {
        // 创建数组型缓冲等待队列
        BlockingQueue<Runnable> bq = new ArrayBlockingQueue<Runnable>(10);
        // ThreadPoolExecutor:创建自定义线程池，池中保存的线程数为3，允许最大的线程数为6
        ThreadPoolExecutor tpe = new ThreadPoolExecutor(3, 6, 50, TimeUnit.MILLISECONDS, bq);
        // 创建3个任务
        Runnable t1 = new TempThread();
        Runnable t2 = new TempThread();
        Runnable t3 = new TempThread();
        Runnable t4 = new TempThread();
        Runnable t5 = new TempThread();
        Runnable t6 = new TempThread();
        // 3个任务分别在3个线程上执行
        tpe.execute(t1);
        tpe.execute(t2);
        tpe.execute(t3);
        tpe.execute(t4);
        tpe.execute(t5);
        tpe.execute(t6);
        // 关闭自定义线程池
        tpe.shutdown();
    }
}