重学Java基础笔记(多线程)

客官°小女子只卖身不卖艺 2022-10-11 13:34 122阅读 0赞

###  多线程： ###

线程就是执行一个入口方法，执行完成线程也就结束了；

线程执行方法的时候遇到方法的调用，就会在线程栈中增加一层，用来保存线程当前的执行状态，比如当前方法的局部变量的值，当前方法执行到哪里等，所以线程栈中的每一层都是方法已经执行但是没有结束的方法，没有结束可能是因为没有执行完，也可能是因为等待调用它的方法执行完（idea的debug可以查看线程栈）；

线程也是一个对象，执行完Runnable接口里的run()方法以后，线程就结束了；

当进程里的所有线程执行结束或者剩下的都是守护线程，那么一个进程也就执行结束了；

守护线程就是为进程中其它线程服务的线程，其它线程都结束了，那么守护线程也没有服务对象了，也就没有存在意义了，守护线程就不会阻碍进程结束；

将线程对象setDaemon(true)，就创建了守护线程；

一段代码可以被多个线程同时执行；

线程优先级，自己手动设置用处不大，可能还不会起作用，操作系统会自己的一套操作；

线程的interrupt方法，就是给线程打一个标记，你可以获取线程的状态，但是要不要理会这个或者处理取决于自己控制；

因为stop()/destroy()方法的弃用，比较好的停止线程的方式是设置一个boolean变量来控制；

**线程的生命周期：**

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTMwNTU2Nzg_size_16_color_FFFFFF_t_70][]

创建线程例子：

class ThreadTest{
        // 创建线程的三种方式
        // 第一种方式：继承 Thread 类，覆盖run()方法
        // 使用继承的方式可以传参数，但是扩展性不好，因为Java单继承
        public static class MyThread extends Thread{
            int a = 0;
            // 因为是继承所以可以有构造方法，可以传值
            public MyThread(int i) {
                a = i;
            }
            @Override
            public void run() {
                System.out.println(a+": 这是一个子线程");
            }
        }
        // 第二种方式：实现Runnable接口的run()方法
        // Runnable只能使用在主线程中声明的final变量，使用接口的好处就是可以多继承
        public static class MyRunnable implements Runnable{
            @Override
            public void run() {
                System.out.println("这是一个子线程");
            }
        }
        // 第三种方式：使用FutureTask，先实现Callable接口的call()方法
        // 可以获得执行结果
        /* Runnable 和 Callable的相同点：
            1：都是接口
            2：都可以编写多线程程序
            3：都采用Thread.start()启动线程
        */
        /* Runnable 和 Callable的不同点：
            1：Runnable没有返回值；
               Callable可以返回执行结果，是个泛型，和Future、FutureTask配合可以用来获取异步执行的结果；
            2：Callable接口的call()方法允许抛出异常；
               Runnable的run()方法异常只能在内部消化，不能往上继续抛
        */
        // 注意：Callalble接口支持返回执行结果，需要调用FutureTask.get()得到，此方法会阻塞主进程的继续往下执行，如果不调用不会阻塞。
        public static class CallerTask implements Callable<String>{
            @Override
            public String call() throws Exception {
                return "这是什么？";
            }
        }
    
        public static void main(String[] args) {
            MyThread myt = new MyThread(1);
            myt.start();
            // Runnable接口实现可以多个线程共用myr的代码逻辑
            MyRunnable myr = new MyRunnable();
            new Thread(myr).start();
            Thread daemonT = new Thread(myr);
            // 设置成为守护线程
            daemonT.setDaemon(true);
            // 启动线程
            daemonT.start();
            // 创建一个异步任务
            FutureTask<String> fu = new FutureTask<>(new CallerTask());
            // 启动线程
            new Thread(fu).start();
            try {
                // get()是一个阻塞方法，等待执行完毕获取执行的结果
                String result = fu.get();
                System.out.println(result);
            } catch (InterruptedException e) {
                e.printStackTrace();
            } catch (ExecutionException e) {
                e.printStackTrace();
            }
        }
    }

** sleep() 和 yield():**

例子：

class SYThread{
        public static class StateThread extends Thread {
            public void run() {
                for (int i = 0; i < 30; i++) {
                    System.out.println(this.getName() + ":" + i);
                    try {
                        // sleep 是让正在运行的线程进入阻塞状态，直到睡眠时间到了，进入就绪状态，优先级低的线程也有执行的机会，而且这个方法的可移植性好
                    // 不过sleep需要捕获异常
                                    Thread.sleep(1);
                            } catch (InterruptedException e) {
                                    e.printStackTrace();
                            }
                // yield 是让正在执行的线程直接进入就绪状态，只会执行优先级高的线程
                    Thread.yield();
                }
            }
        }
        public static void main(String[] args) {
            StateThread thread1 = new StateThread();
            thread1.start();
            StateThread thread2 = new StateThread();
            thread2.start();
        }
    }

**同步控制 synchronized：**

多线程访问同一个对象实例的成员变量时会产生结果的混乱，多线程访问和修改数据可能是一个穿插的顺序，比如当一个线程访问变量并计算变量的值，但是在计算以后写入之前另一条线程写入了一个新的值，然后这条线程的值就会覆盖刚才的值，这样就会导致结果有问题，而且现在的CPU可能会有缓存机制，就是线程先获取到变量的值，也不会计算一次写入一次，直接一次性全部计算好在写入，这样多线程下结果就会更加混乱；

为了结果这个问题，可以使用同步控制synchronized来修饰计算的方法，这样对于同一实例对象来说就能保证同一时间只有一条线程执行，别的线程需要等待当前线程处理完成以后再执行，而且使用了synchronized以后就不会出现CPU缓存的问题，每一次的计算以后都要直接写入，但是synchronized 方法效率很低，因为原本多线程的执行，到了synchronized方法这里就要一个个排队执行，而且还需要加上线程调度的开销时间；

synchronized意味着线程需要获得操作实例对象的锁，才能执行代码块的内容，这个实例对象的锁称为“互斥锁”，同一时间只有一个线程可以访问，没有获得锁的线程会进入实例对象的“锁池队列”中等待其它线程执行完毕释放锁；

synchronized可以修饰静态方法，这样就不是针对一个实例对象，而是这个类下面的所有实例对象；

**synchronized的实现：**

第一种：synchronized方法，就是在方法上加入synchronized修饰符就可以；但是这个方法很影响效率，因为可能只是操作对象的某一个属性计算，但是却把整个方法都同步了；

第二种：synchronized方法块，synchronized(Object)\{ ..... \}，参数就是要操作的实例对象；

例子：

class TestSync {
        public static void main(String[] args) {
            Account a1 = new Account(100, "xxx");
            Drawing draw1 = new Drawing(30, a1);
            Drawing draw2 = new Drawing(10, a1);
            draw1.start();
            draw2.start();
        }
    
    }
    // 账户
    class Account {
        int money; // 账户余额
        String aname; // 账户名字
        public Account(int money, String aname) {
            super();
            this.money = money;
            this.aname = aname;
        }
    }
    // 取钱
    class Drawing extends Thread {
        int drawingNum; // 取钱数目
        Account account; // 取钱账户
        int expenseTotal; // 总额
        // 初始化
        public Drawing(int drawingNum, Account account) {
            super();
            this.drawingNum = drawingNum;
            this.account = account;
        }
        @Override
        public void run() {
            // 取钱行为
            draw();
        }
        // 取钱实际行为
        void draw() {
            // 这里就用到了synchronized方法体，给一个操作对象，不同步的结果混乱就是因为没有对同一对象的同一属性进行同步造成的
            // 将对这个对象的成员变量的操作放在里面
            synchronized (account) {
                if (account.money - drawingNum < 0) {
                    System.out.println(this.getName() + "余额不足");
                    return;
                }
                try {
                    Thread.sleep(10); // 阻塞线程
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                account.money -= drawingNum;
                expenseTotal += drawingNum;
            }
            System.out.println(this.getName() + "账户余额：" + account.money);
            System.out.println(this.getName() + "总共取了：" + expenseTotal);
        }
    }

**同步控制 wait notify：**

应用场景，就是多线程有互动的情况下使用，比如一个线程需要等待另一个线程操作后来唤醒再执行，这样的情况；

wait()以后会自动失去对象的锁，这样别的线程就可以进入synchronized的代码块；

等到notify()或者notifyAll()以后需要重新获得对象的锁，但是因为synchronized是不公平锁，所以哪一个线程能获得这个锁是不一定；

wait(1000)可以有参数，就是超时时间，单位毫秒，如果超过时间将自动唤醒

wait()/notify()/notifyAll()，这几个方法是属于Object类的，因为每个对象都有锁，所有就会有对锁的操作

例子：

// wait()/notify()/notifyAll()，这几个方法是属于Object类的，因为每个对象都有锁，所有就会有对锁的操作
    class WaitTest{
        static int total = 0;
        public static void main(String[] args) {
            // 设置一个对象
            Object obj = new Object();
            // 这是main方法的主线程
            System.out.println("主线程开始");
            // 创建一个线程类，用lambda的方式
            new Thread(() -> {
                // 使用wait()/notify()/notifyAll()之前必须先获得锁，所以需要放在synchronized代码块中确保已经获得锁
                // 获取对象的锁
                synchronized (obj){
                    System.out.println("线程B正在运行");
                    for (int i = 0; i < 5; i++) {
                        total += i;
                        System.out.println("total is " + total);
                    }
                    // 这里通知等待中的线程已经好了
                    // 因为这里只有一条线程所以用notify()，如果要通知所有线程使用notifyAll()
                    // 这里其实有一个问题就是，因为主线程是main，创建和启动线程B以后，main和B就会并行执行，如果先执行到了B线程中notify()而不是主线程的wait()的话，那没将永远不会被通知到
                    // wait()和notify()的先后顺序不能错，否则将无法通知到将唤醒的线程
                    // 必须是同一个对象实例
                    obj.notify();
                }
            }).start();
            // B线程启动以后
            System.out.println("B线程开始运行");
            // 主线程获得对象的锁
            synchronized (obj){
                System.out.println("等待B线程完成");
                try {
                    // 然后实例对象在这里等待被B线程通知唤醒
                    obj.wait();
                    System.out.println("线程B完成，回归主线程");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            System.out.println("主线程结束");
        }
    }

**线程同步 join：**

线程的join()方法像是将原本并行的线程变为串形，比如在A线程中调用B线程的join()，那A就会等B执行完以后再执行；

join(1)方法可以有参数，单位是毫秒，如果超过时间，线程又回到并行

注意：join(0)不是零毫秒，而是无限期；

join方法的原理就是调用相应线程的wait方法进行等待操作的，例如A线程中调用了B线程的join方法，则相当于在A线程中调用了B线程的wait方法，当B线程执行完（或者到达等待时间），B线程会自动调用自身的notifyAll方法唤醒A线程，从而达到同步的目的。

例子：

class TestThreadState {
        // 父亲类
        public static class FatherThread  implements  Runnable {
            public void run() {
                System.out.println("爸爸发现冰箱没有菜了，就让儿子出去买菜");
                // 可以放在父亲类里，也可以在main方法创建儿子线程，放在main方法中就是父亲对象线程先start()再join()，然后儿子线程start()
                // 放在父亲类的好处是可以将等待完成以后的行为放在这里
                Thread son = new Thread(new SonThread());
                son.start();
                System.out.println("爸爸等待儿子买菜回来");
                try {
                    // join()方法需要捕捉异常，join(1)可以有参数，是等待时间，单位毫秒，如果超过时间了，线程又回到并行
                    // 这里注意，join(0)不是零毫秒，而是无限期
                    // 这里就等待儿子买菜回来才会执行下面的语句
                    son.join();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                    System.out.println("好像出了点问题，爸爸出门去找儿子");
                    System.exit(1); // 结束JVM，0是正常退出，非零是非正常退出
                }
                System.out.println("爸爸拿过菜开始做饭");
            }
        }
        // 儿子类
        public static class SonThread implements Runnable {
            public void run() {
                System.out.println("儿子出去买菜");
                try {
                    for (int i = 1; i <=10;i++) {
                        System.out.println("第" + i + "分钟");
                        Thread.sleep(1000);
                    }
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("儿子买菜回来了");
            }
        }
        public static void main(String[] args) {
            Thread father = new Thread(new FatherThread());
            father.start();
        }
    }

###  ###

### 死锁： ###

死锁产生的必要条件：

产生死锁必须同时满足以下四个条件，只要其中任一条件不成立，死锁就不会发生。

（1）互斥条件：进程要求对所分配的资源（如打印机）进行排他性控制，即在一段时间内某资源仅为一个进程所占有。此时若有其他进程请求该资源，则请求进程只能等待。

人话：就是A线程锁定一个资源没释放，又想去获得另一个资源，这时候呢B线程正好锁着这个资源不放，那A线程就只能等着；

（2）不剥夺条件：进程所获得的资源在未使用完毕之前，不能被其他进程强行夺走，即只能由获得该资源的进程自己来释放（只能是主动释放)。

人话：就是A线程锁定的资源在没有正常完成的情况下别的线程无法拿到也没法帮它关闭，只能A线程自己关闭

（3）请求和保持条件：进程已经保持了至少一个资源，但又提出了新的资源请求，而该资源已被其他进程占有，此时请求进程被阻塞，但对自己已获得的资源保持不放。

人话：A线程锁着一个资源不放，又要去获得新的资源，但是这个资源被B线程占有着，这时候整个线程就阻塞住了，A线程呢对自已的资源也不释放；（怎么感觉和第一个一样呢）

（4）循环等待条件：存在一种进程资源的循环等待链，链中每一个进程已获得的资源同时被链中下一个进程所请求。即存在一个处于等待状态的进程集合\{Pl, P2, ..., pn\}，其中Pi等 待的资源被P(i+1)占有（i=0, 1, ..., n-1)，Pn等待的资源被P0占有

人话：就是请求资源的线程形成了一个闭环，A线程拿着C线程想要的资源去请求B线程正持有的资源，B线程又去请求C线程的资源；

解决死锁的方式：

所有的线程申请资源的顺序都一样，这样就不会混乱了

写一个死锁的程序：

// 写一个死锁程序死锁
    // 两个线程获取两个对象的锁，并且等待对方释放以后获取对方对象的锁
    class Makeup extends Thread {
        int flag;
        String girl;
        // 口红
        static Object lipstick = new Object();
        // 镜子
        static Object mirror = new Object();
    
        @Override
        public void run() {
            doMakeup();
        }
    
        void doMakeup() {
            if (flag == 0) {
                // 先获得口红对象的锁
                synchronized (lipstick) {
                    System.out.println(girl + "拿着口红");
                    try {
                        Thread.sleep(20);
    
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    // 需要获得镜子对象的锁
                    // B线程已经获得镜子对象的锁，正等待A释放口红对象的锁
                    synchronized (mirror) {
                        System.out.println(girl + "拿着镜子");
                    }
    
                }
            } else {
                // 先获得镜子对象的锁
                synchronized (mirror) {
                    System.out.println(girl + "拿着镜子");
                    try {
                        Thread.sleep(20);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    // 还想获得口红对象的锁
                    // 这时A线程已经获得口红对象的锁，正等待B释放镜子对象的锁
                    // 如何破解这个死锁，其实只需要让B线程获取锁的顺序和A线程一样就可以了，这里也改成先获取口红对象的锁，再获取镜子对象的锁
                    synchronized (lipstick) {
                        System.out.println(girl + "拿着口红");
                    }
                }
            }
        }
    }
    class TestDeadLock {
        public static void main(String[] args) {
            Makeup m1 = new Makeup();
            m1.girl = "小红";
            // 0，这个线程先去获取口红的锁
            m1.flag = 0;
            Makeup m2 = new Makeup();
            m2.girl = "大红";
            // 1，这个线程先去获得镜子的锁
            m2.flag = 1;
            // 启动两个线程以后就会发现死锁了，A线程拿着口红后又想去获得镜子的资源，但是B线程先获得了镜子的资源不放又要去获得口红资源
            m1.start();
            m2.start();
            // 解决死锁的方法就是获取锁的顺序一样，都是先去获得口红再去获得镜子就可以了
            // 进入同步以后，另一个线程只能等待先拿到锁的线程释放掉以后才能再拿到这个锁
        }
    }

**LocalThread：**

LocalThread的作用是用来做数据隔离，相当于每个线程都有自己数据的副本，互不干预；

一般用于存放线程级别的全局变量，实现数据隔离的功能；

Thread为每个线程维护了ThreadLocalMap这么一个Map，而ThreadLocalMap的key是LocalThread对象本身，value则是要存储的对象；

使用的例子：

// 一般用于存放线程级别的全局变量，实现数据隔离的功能
    // 比如JDBC中的Connection，确保每个线程连接操作的都是同一个Connection，保证事物的一致性；
    class ThreadLocalTest{
        // 创建一个存放String的ThreadLocal
        static  ThreadLocal<String> localData = new ThreadLocal<>();
        static void myPrint(String str){
            // 通过get()方法获取当前线程里的数据
            System.out.println(str+localData.get());
            // 删除当前线程里ThreadLocal里存放的变量
            localData.remove();
        }
        public static void main(String[] args) {
            // 创建一个线程
            new Thread(() -> {
                // 给线程的ThreadLocal里设置数据
                localData.set("这是线程a的数据");
                // 打印并删除数据
                myPrint("一：");
            }).start();
    
            // 创建另一个线程
            new Thread(() -> {
                localData.set("这是线程b的数据");
                myPrint("二：");
            }).start();
        }
    }

### 定时任务： ###

先学几个类：

Calendar类，可以对时间进行加减，也可以自己设置一个时间，然后用getTime()转为Date类；

SimpleDateFormat类，可以把Date类格式化，但是这是一个线程不安全的类，如果要使用设置成ThreadLocal；

定时任务使用TimerTask类；

例子：

class TimerTaskTest {
        public static void main(String[] args) {
            // 创建一个Timer对象
            Timer t = new Timer();
            t.scheduleAtFixedRate(new TimerTask() {
                @Override
                public void run() {
                    // TimerTask里的run()方法里的异常要捕捉，不能抛给Timer，Timer是不会处理的，就会导致整个Timer挂掉
                    System.out.println("hello world");
                }
                // 这里两个参数，一个是延时多久执行，一个是执行周期(就是隔多久执行一次这个方法)
            }, 20, 1000);
        }
    }

**volatile 关键字：**

指令重排，就是Java内存模型有一套自己的规范，出于优化的目的去影响内存和缓存；

比如多个变量赋值操作，只要最后的结果没有错过的情况下，指令重排会进行优化，赋值的顺序不一定就是代码的顺序；

volatile 关键字就是影响指令重排的，直接从主内存中获取最新的值，而不是缓存中;

volatile 还有一个作用就是volatile 实现了一种内存可见性，就是一个线程修改了某个值会去通知其他线程，它修改了，其它线程会看到这个修改的状态，但是无法保证数据的原子性，对于多线程它不是互斥关系；

例子：

class VolatileTest {
        int a, b, c, d, f, g;
        long e;
        // TODO 有 volatile 修饰就会影响之前的指令重排
        // 使用volatile修饰以后就会正常，g>e的情况就没有了
        // volatile long e;
    
        public void operateData() {
            // TODO 按照这个顺序执行，g 的值是肯定小于等于 e 的。但是实际执行在执行的时候，可能会为了优化的目的重排
            a += 1;
            b += 1;
            c += 1;
            d += 1;
    
            e += 1;
    
            f += 1;
            g += 1;
        }
        int counter;
        public void check() {
            // TODO 看似不可能的条件，实际可能被触发到
            // 正常的直觉觉得这个条件是不可能会触发的，但是因为指令重排的原因确实会触发；
            if (g > e) {
                System.out.println("got it " + (counter++));
            }
        }
    }
    
    class VolatileAppMain {
        public static void main(String[] args) {
            VolatileTest dataHolder = new VolatileTest();
            // 这里创建两个线程，一个执行赋值操作，一个执行比较操作，看看会不会出现g>e的情况
            Thread operator = new Thread(() -> {
                while (true) {
                    dataHolder.operateData();
                }
            });
            operator.start();
    
            Thread checker = new Thread(() -> {
                while (true) {
                    dataHolder.check();
                }
            });
            checker.start();
        }
    }

### concurrent 包： ###

concurrent 包的基础原理：

使用 CAS，避免内核调用。CAS 命令是现代 CPU 都支持的一种指令。这个指令对一个数据的写操作，需要三 个操作数：内存里的值的地址，旧的值，新的值。只有当 内存里的值 == 旧 的值，内存里的值才会被设置为新的值。但是CAS比较失败的时候不会放弃CPU，会反复执行，直到自己修改主内存的数据；这个操作是原子操作，不会被 CPU 执行调度打断；

**concurrent.atomic：**

基础类型都有对应的atomic类，atomic是为了多线程访问成员变变量时保持原子性，它比synchronized更轻量化，因为synchronized时锁住一片代码块，而它只是一个值或者引用，当别的A线程访问atomic方法时，不会被别的线程打断，而别的要访问atomic方法的线程会一直访问，直到上个一个线程完成以后它才开始执行里面的方法；

一般常用的类：AtomicInteger，AtomicLong

常用的方法：

get() 直接返回值

getAndAdd(int) 增加指定的数据，返回变化前的数据

getAndDecrement() 减少1，返回减少前的数据

getAndIncrement() 增加1，返回增加前的数据

getAndSet(int) 设置指定的数据，返回设置前的数据

addAndGet(int) 增加指定的数据后返回增加后的数据

decrementAndGet() 减少1，返回减少后的值

incrementAndGet() 增加1，返回增加后的值

lazySet(int) 仅仅当get时才会set

compareAndSet(int, int) 尝试新增后对比，若增加成功则返回true否则返回false

例子：

class AtomicTest{
        // 设置一个AtomicInteger成员变量
        AtomicInteger i = new AtomicInteger(0);
        public static void main(String[] args) {
            AtomicTest ato = new AtomicTest();
            // 创建两个线程，一个自增，一个自减，可以从两个线程内的结果看出，成员变量的结果是正确的，说明操作是具有原子性的；
            new Thread(()->{
                // 这里的结果是1
                System.out.println(ato.i.incrementAndGet());
            }).start();
            new Thread(()->{
                // 这里的结果是0
                System.out.println(ato.i.decrementAndGet());
            }).start();
        }
    }

concurrent 包中的锁：

**ReentrantLock 锁：**

ReentrantLock是一个类，属于乐观锁类型，多线程并发情况下。能保证共享数据安全性，线程间有序性，它可以通过原子操作和阻塞实现锁原理，一般使用lock()获取锁，unlock()释放锁；

它相较于synchronized更轻量化，因为synchronized是JVM控制的锁，无法中途打断，也是由JVM控制锁的释放；

ReentrantLock可以设置成公平锁ReentrantLock(true)(默认是不公平锁)，而synchronized只有不公平锁，ReentrantLock还可以根据条件唤醒对应的线程，而synchronized只能随机唤醒线程或者全部唤醒；

简单使用lock()和unlock()例子（改写之前synchronized的银行取钱代码）：

// 整体没什么变化就是将synchronized方法体去掉，在需要操作的变量之前加上锁，最后释放锁
    class TestSyncx {
        public static void main(String[] args) {
            Accountx a1 = new Accountx(100, "xxx");
            Drawingx draw1 = new Drawingx(30, a1);
            Drawingx draw2 = new Drawingx(10, a1);
            draw1.start();
            draw2.start();
        }
    }
    // 账户
    class Accountx {
        int money; // 账户余额
        String aname; // 账户名字
        public Accountx(int money, String aname) {
            super();
            this.money = money;
            this.aname = aname;
        }
    }
    // 取钱
    class Drawingx extends Thread {
        int drawingNum; // 取钱数目
        Accountx account; // 取钱账户
        int expenseTotal; // 总额
        static ReentrantLock lock = new ReentrantLock();
        // 初始化
        public Drawingx(int drawingNum, Accountx account) {
            super();
            this.drawingNum = drawingNum;
            this.account = account;
        }
        @Override
        public void run() {
            // 取钱行为
            draw();
        }
        // 取钱实际行为
        void draw() {
            // 将原本这里就用到了synchronized方法体去掉
            if (account.money - drawingNum < 0) {
                System.out.println(this.getName() + "余额不足");
                return;
            }
            try {
                Thread.sleep(10); // 阻塞线程
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            try {
                // 在需要操作的变量之前加上锁，然后进行操作，这里将进入同步操作
                lock.lock();
                account.money -= drawingNum;
                expenseTotal += drawingNum;
                System.out.println(this.getName()+"账户余额：" + account.money);
                System.out.println(this.getName()+"总共取了：" + expenseTotal);
            }catch (Exception e){
                e.printStackTrace();
            }finally {
                // 一定要释放锁
                lock.unlock();
            }
        }
    }

ReentrantLock也有对应的wait/notify/notifyAll，分别是await()/signal()/signalAll()，相比于notify随机唤醒的方式，signal是可以用if等判断语句，根据条件唤醒线程；

await()/signal()/signalAll()简单使用的例子：

// await()/signal()/signalAll()，这几个方法是属于Condition类的
    class NewWaitTest{
        public static void main(String[] args) {
            // 先创建ReentrantLock对象
            ReentrantLock lock = new ReentrantLock();
            // 创建Condition对象，因为不同于synchronized中的wait()/notify()/notifyAll()方法都是Object对象的，await()/signal()/signalAll()是Condition对象的方法
            Condition condition = lock.newCondition();
            // 这是main方法的主线程
            System.out.println("主线程开始");
            // 创建一个线程类，用lambda的方式
            for (int i = 0; i < 5; i++) {
                new Thread(() -> {
                    // 使用wait()/notify()/notifyAll()之前必须先获得锁，所以需要放在synchronized代码块中确保已经获得锁
                    // 获取对象的锁
                    try {
                        // 和wait()/notify()/notifyAll()一样，await()/signal()/signalAll()也需要先获得锁
                        //lock()获得锁
                        lock.lock();
                        Thread.sleep(1000);
                        System.out.println("等待：" + Thread.currentThread().getName());
                        // 和wait()和notify()一样，await()/signal()也有先后顺序，如果先signal后await就无法唤醒线程
                        condition.await();
                        // 唤醒以后就能执行下面的代码了
                        System.out.println("等待结束，继续.....：" + Thread.currentThread().getName());
                    } catch (Exception e) {
                        e.printStackTrace();
                    } finally {
                        // 一定要释放锁
                        lock.unlock();
                    }
                }).start();
            }
            try {
                Thread.sleep(2000);
                // 唤醒也一样，需要先获得锁
                lock.lock();
                // signalAll()是全部唤醒
                // condition.signalAll();
                // System.out.println("全部唤醒");
                // signal是逐个唤醒
                for(int i=0; i<5;i++){
                    condition.signal();
                    System.out.println("逐个唤醒");
                }
            }catch (Exception e){
                e.printStackTrace();
            }finally {
                // 一定要释放锁
                lock.unlock();
            }
            System.out.println("主线程结束");
        }
    }

使用**CountDownLatch**模拟join操作，例子：

//改写之前爸爸让儿子买菜的join()代码
    class NewTestThreadState {
        // 创建一个CountDownLatch对象，构造函数里是传入需要处理的线程数，就是一个计数器
        static CountDownLatch coun = new CountDownLatch(1);
        // 父亲类
        public static class NewFatherThread  implements  Runnable {
            public void run() {
                System.out.println("爸爸发现冰箱没有菜了，就让儿子出去买菜");
                // 可以放在父亲类里，也可以在main方法创建儿子线程，放在main方法中就是父亲对象线程先start()再await()，然后儿子线程start()
                // 放在父亲类的好处是可以将等待完成以后的行为放在这里
                Thread son = new Thread(new NewSonThread());
                son.start();
                System.out.println("爸爸等待儿子买菜回来");
                try {
                    // await()方法需要捕捉异常
                    // 这里就等待儿子买菜回来才会执行下面的语句
                    // await()方法，检查计数器为0以后，才会继续往下执行
                    coun.await();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                    System.out.println("好像出了点问题，爸爸出门去找儿子");
                    System.exit(1); // 结束JVM，0是正常退出，非零是非正常退出
                }
                System.out.println("爸爸拿过菜开始做饭");
            }
        }
        // 儿子类
        public static class NewSonThread implements Runnable {
            public void run() {
                System.out.println("儿子出去买菜");
                try {
                    for (int i = 1; i <=10;i++) {
                        System.out.println("第" + i + "分钟");
                        Thread.sleep(100);
                    }
                    // countDown()方法会减少计数器
                    coun.countDown();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("儿子买菜回来了");
            }
        }
        public static void main(String[] args) {
            Thread father = new Thread(new NewFatherThread());
            father.start();
        }
    }

**concurrent包中的数据结构：**

concurrent包中的数据结构以高效支持线程安全为特色，经常会使用的有LinkedBlockingQueue和ConcurrentHashMap；

** LinkedBlockingQueue：**

LinkedBlockingQueue是一个单向链表实现的阻塞队列，先进先出，可以指定队列大小也可以不指定，不指定就是Integer.MAX\_VALUE，LinkedBlockingQueue实现了BlockingQueue接口，它支持多线程并发。当多线程竞争同一个资源时，某线程获取到该资源之后，其它线程需要阻塞等待，putLock是插入锁，takeLock是取出锁；notEmpty是“非空条件”，notFull是“未满条件”；

取数据的流程：

当A线程取数据，队列为空的时候，该线程会执行notEmpty.await()进行等待，当B线程插入数据以后会调用notEmpty.signal()唤醒notEmpty上的等待线程，A线程取数据前会先获取得takeLock锁，等到操作完成会释放takeLock锁；

插入数据流程：

当A线程插入数据，队列满了的时候，该线程会执行notFull.await()进行等待，当B线程取出数据以后会调用notFull.signal()唤醒notFull上的等待线程，A线程插入数据前会先获得putLock锁，等操作完以后会释放putLock锁；

例子：

class CollectionAppMain {
        // 用来计数元素个数，其实可以用size()获取队列大小
        static int num = 0;
        public static void main(String[] args) {
            // 创建一个LinkedBlockingQueue对象，只能装最多6个元素
            // 运行结果以后可以发现计数没有超过设定的6
            LinkedBlockingQueue<String> linkedBlockingQueue = new LinkedBlockingQueue<>(6);
            // 四个线程对象，每个对象可以生产5个馒头
            for(int i=0;i<4;i++) {
                new Thread(() -> {
                    for(int a=0;a<5;a++){
                        // 判断是队列是否空了，isEmpty()队列为空会返回true
                        // 其实这里没有必要，只是演示
                        if(linkedBlockingQueue.isEmpty()){
                            num=0;
                        }
                        try {
                            // put()添加元素，如果队列满了会阻塞
                            // offer()也是添加元素，但是不会阻塞，满了会返回false，所以就会出现超过6的情况
                            linkedBlockingQueue.put("馒头");
                            num += 1;
                            System.out.println(Thread.currentThread().getName() + "：生产了一个馒头");
                            System.out.println("----目前一共有："+num+"个馒头");
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                }).start();
            }
            // 四个线程对象，每个对象可以吃掉5个馒头
            // 这里生产和消费的线程数和执行次数一样，不然整个程序就会阻塞住
            // 如果生产太多消费太少，生产就会等着消费者来消费，但是这时候已经没有消费者了，就会一直阻塞，相反同理
            for(int i=0;i<4;i++) {
                new Thread(() -> {
                    for(int a=0;a<5;a++) {
                        if(linkedBlockingQueue.isEmpty()){
                            num=0;
                        }
                        try {
                            // take()用来取数据，如果队列空了会阻塞
                            linkedBlockingQueue.take();
                            num -=1;
                            System.out.println(Thread.currentThread().getName() + "：吃掉了一个馒头");
                            System.out.println("----目前一共有："+num+"个馒头");
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                }).start();
            }
        }
    }

**ConcurrentHashMap：**

在多线程环境下，使用HashMap进行put操作时存在丢失数据的情况；

HashTable是一个线程安全的类，它使用synchronized来锁住整张Hash表来实现线程安全，即每次锁住整张表让线程独占，相当于所有线程进行读写时都去竞争一把锁，导致效率非常低下；

ConcurrentHashMap可以做到读取数据不加锁，并且其内部的结构可以让其在进行写操作的时候能够将锁的粒度保持地尽量地小，允许多个修改操作并发进行，其关键在于使用了锁分段技术。它使用了多个锁来控制对hash表的不同部分进行的修改；

ConcurrentHashMap 优点：设计为非阻塞的。在更新时会局部锁住某部分数据，但不会把整个表都锁住。同步读取操作则是完全非阻塞的。好处是在保证合理的同步前提下，效率很高；

ConcurrentHashMap 缺点：因为读取数据没有加锁，严格来说读取操作不能保证反映最近的更新；

例子：

class ConcurrentMapAppMain{
        public static void main(String[] args) {
            Map<String, List<Integer>> map = new ConcurrentHashMap<>();
            String k1 = "1";
            // put()方法添加数据
            map.put(k1, new ArrayList<>());
            // get()方法获取数据
            System.out.println("put："+map.get(k1));
            List<Integer> newList = new ArrayList<>();
            newList.add(999);
            // putIfAbsent()方法，key不存在时添加键值对，否则不会添加
            map.putIfAbsent(k1, newList);
            System.out.println("putIfAbsent:" + map.get(k1));
    
            // compute()方法，key存在会修改原来的值，如果key不存在会报错
            map.compute(k1, (k, v) -> {
                v.add(1);
                return v;
            });
            System.out.println("compute:" + map.get(k1));
    
            // computeIfPresent()方法，key存在会修改原来的值，如果key不存在返回null不报错
            map.computeIfPresent(k1, (k, v) -> {
                v.add(999);
                return v;
            });
            System.out.println("computeIfPresent:" + map.get(k1));
        }
    }

线程池 **ExecutorService**：

例子：

class ThreadPoolAppMain{
        public static void main(String[] args) {
            // 创建一个线程池，数量为1
            // 感觉相当于一个队列池子，将需要执行的任务分配到不同的队列里排队执行
            ExecutorService executorService = Executors.newFixedThreadPool(1);
            // submit()方法提交任务，参数可以是Callable 或 Runnable
            // 这里先用Runnable，Runnable没有返回值，不能查看执行结果
            executorService.submit(() -> {
                System.out.println(Thread.currentThread().getName()+"执行Runnable的run方法，没有返回");
            });
            System.out.println("已经提交Runnable的run任务");
            // Future对象可以接收任务结果，Callable和Runnable的lambda写法一样，区别在于Callable有return返回值，可以赋值给Future对象
            Future<String> future = executorService.submit(() -> {
                System.out.println(Thread.currentThread().getName()+"执行Callable的call方法");
                return "这是Callable的call方法返回的结果";
            });
            System.out.println("已经提交Callable的call任务");
            try {
                // get()方法是会阻塞，直到拿到结果
                String result = future.get();
                System.out.println("获取Callable的call任务的返回值："+result);
            } catch (InterruptedException e) {
                e.printStackTrace();
            } catch (ExecutionException e) {
                e.printStackTrace();
            }
            // 关闭线程池
            // 注意，只要提交了任务，就算将关闭线程池的代码提前到提交任务以后，也会等到提交的任务执行完才会关闭
            executorService.shutdown();
            System.out.println("线程池关闭");
        }
    }

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTMwNTU2Nzg_size_16_color_FFFFFF_t_70]: /images/20221005/be0d360aac374ca7bf8206f09d65a2b7.png