zoukankan html css js c++ java

Java进阶: 多线程线程状态?为什么使用线程池?如何创建线程池?如何解决线程安全?线程安全-可见性,线程安全-原子性,并发容器注意特点.并发工具类

　　　　　　　　　　　　　　　　　　　　　　　　　　重难点梳理

　　　　　　　　　　　　　　　　　　　　　　　　知识点梳理

　　　　　　　　　　　　　　　　　　　　　　　　学习目标

1、能够知道java中线程的相关状态以及各个状态之间的转换过程

2、能够理解什么是线程池(概述，Executors方式创建线程池，ThreadPoolExecutor方式创建线程池，线程池原理说明)

3、能够了解volatile关键字的语义（特点）

4、能够知道什么是原子性(原子性概述，常见原子类的使用，CAS算法)

5、能够掌握jdk中提供的线程并发工具类的使用（ConcurrentHashMap，CountDownLatch，Semaphore）

　　　　　　　　　　　　　　　　　　　　　　　　超详细讲义

==知识点==

1.线程状态

2.线程池

3.volatile

4.原子性

5.并发工具包

1. 线程状态介绍【记忆】

(共3点)

1.线程状态介绍

当线程被创建并启动以后，它既不是一启动就进入了执行状态，也不是一直处于执行状态。线程对象在不同的时期有不同的状态,同一时刻线程只能存于一种状态

2.各个状态的转换，如下图所示：

3.Java中的线程存在哪几种状态呢？

Java中的线程状态被定义在了java.lang.Thread.State枚举类中，State枚举类的源码如下：

public class Thread {
    
    public enum State {
    
        /* 新建 */
        NEW , 

        /* 可运行状态 */
        RUNNABLE , 

        /* 阻塞状态 */
        BLOCKED , 

        /* 无限等待状态 */
        WAITING , 

        /* 计时等待 */
        TIMED_WAITING , 

        /* 终止 */
        TERMINATED;
    
    }
    
    // 获取当前线程的状态
    public State getState() {
        return jdk.internal.misc.VM.toThreadState(threadStatus);
    }
    
}

通过源码我们可以看到Java中的线程存在6种状态，每种线程状态的含义如下

线程状态	具体含义
NEW	一个尚未启动的线程的状态。也称之为初始状态、开始状态。线程刚被创建，但是并未启动。还没调用start方法。MyThread t = new MyThread()只有线程象，没有线程特征。
RUNNABLE	当我们调用线程对象的start方法，那么此时线程对象进入了RUNNABLE状态。那么此时才是真正的在JVM进程中创建了一个线程，线程一经启动并不是立即得到执行，线程的运行与否要听令与CPU的调度，那么我们把这个中间状态称之为可执行状态(RUNNABLE)也就是说它具备执行的资格，但是并没有真正的执行起来而是在等待CPU的度。
BLOCKED	当一个线程试图获取一个对象锁，而该对象锁被其他的线程持有，则该线程进入Blocked状态；当该线程持有锁时，该线程将变成Runnable状态。
WAITING	一个正在等待的线程的状态。也称之为等待状态。造成线程等待的原因有两种，分别是调用Object.wait()、join()方法。处于等待状态的线程，正在等待其他线程去执行一个特定的操作。例如：因为wait()而等待的线程正在等待另一个线程去调用notify()或notifyAll()；一个因为join()而等待的线程正在等待另一个线程结束。
TIMED_WAITING	一个在限定时间内等待的线程的状态。也称之为限时等待状态。造成线程限时等待状态的原因有三种，分别是：Thread.sleep(long)，Object.wait(long)、join(long)。
TERMINATED	一个完全运行完成的线程的状态。也称之为终止状态、结束状态

2.线程池

2.1 线程池-基本原理【难点】

（共3点）

1.什么是线程池？

存线程的容器就是线程池

2.线程池的原理？

==3.为什么要使用线程池？==

用少量的线程执行更多的任务，提高线程的利用率

2.2 线程池-Executors默认线程池【了解】

1.如何创建线程池？

使用Executors中所提供的静态方法来创建线程池

static ExecutorService newCachedThreadPool() 创建一个默认的线程池 static ExecutorService newFixedThreadPool(int nThreads) 创建一个指定最多线程数量的线程池

2.如何把线程放到线程池中？（ExecutorServicer）

方法	说明
Future<?> submit(Runnable task	提交一个可运行的任务执行，并返回一个表示该任务的未来。

3.如何关闭线程池？

方法	说明
void shutdown()	关闭线程池，先前提交的任务将被执行，但不会接受任何新任务

代码实现 :

package com.itheima.mythreadpool;


//static ExecutorService newCachedThreadPool•()   创建一个默认的线程池
//static newFixedThreadPool•(int nThreads)      创建一个指定最多线程数量的线程池

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

public class MyThreadPoolDemo {
    public static void main(String[] args) throws InterruptedException {

        //1,创建一个默认的线程池对象.池子中默认是空的.默认最多可以容纳int类型的最大值.
        ExecutorService executorService = Executors.newCachedThreadPool();
        //Executors --- 可以帮助我们创建线程池对象
        //ExecutorService --- 可以帮助我们控制线程池

        executorService.submit(()->{
            System.out.println(Thread.currentThread().getName() + "在执行了");
        });

        //Thread.sleep(2000);

        executorService.submit(()->{
            System.out.println(Thread.currentThread().getName() + "在执行了");
        });

        executorService.shutdown();//关闭后不能再提交了，因此后面的代码会报错
        executorService.submit(()->{
            System.out.println(Thread.currentThread().getName() + "在执行了");
        });
    }
}

2.3 线程池-Executors创建指定上限的线程池【了解】

使用Executors中所提供的静态方法来创建线程池

static ExecutorService newFixedThreadPool(int nThreads) : 创建一个指定最多线程数量的线程池

代码实现 :

package com.itheima.mythreadpool;

//static ExecutorService newFixedThreadPool•(int nThreads)
//创建一个指定最多线程数量的线程池

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

public class MyThreadPoolDemo2 {
    public static void main(String[] args) {
        //参数不是初始值而是最大值
        ExecutorService executorService = Executors.newFixedThreadPool(10);

        ThreadPoolExecutor pool = (ThreadPoolExecutor) executorService;
        System.out.println(pool.getPoolSize());//0

        executorService.submit(()->{
            System.out.println(Thread.currentThread().getName() + "在执行了");
        });

        executorService.submit(()->{
            System.out.println(Thread.currentThread().getName() + "在执行了");
        });

        System.out.println(pool.getPoolSize());//2
//        executorService.shutdown();
    }
}

==如果线程执行完没有返回值，未来的get方法将在成功完成后返回null；如果线程执行完有返回值，未来的get方法将在成功完成后返回线程执行完的返回值==

2.4 线程池-ThreadPoolExecutor 【重点】

创建线程池对象 :

ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(核心线程数量,最大线程数量,空闲线程最大存活时间,任务队列,创建线程工厂,任务的拒绝策略);

代码实现 :

package com.itheima.mythreadpool;


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

public class MyThreadPoolDemo3 {
//     参数一：核心线程数量---正式员工                      --不能小于0--
//     参数二：最大线程数---  餐厅最大员工数                 --不能小于0，最大数量>=核心线程数量--
//     参数三：空闲线程最大存活时间--- 临时员工空闲多长时间被辞退(值)    --不能小于0--
//     参数四：时间单位 ---临时员工空闲多长时间被辞退(单位)    --时间单位--
//     参数五：任务队列 ---排队的客户                         --不能为null--
//     参数六：创建线程工厂 ---从哪里招人                      --不能为null--
//     参数七：任务的拒绝策略 ---排队的人过多，超出顾客请下次再来(拒绝服务)   --不能为null--
    public static void main(String[] args) {
        ThreadPoolExecutor pool = new ThreadPoolExecutor(2,5,2,TimeUnit.SECONDS,new ArrayBlockingQueue<>(10), Executors.defaultThreadFactory(),new ThreadPoolExecutor.AbortPolicy());
        pool.submit(new MyRunnable());
        pool.submit(new MyRunnable());

        pool.shutdown();
    }
}

2.5 线程池-参数详解【难点】

package com.itheima.mythreadpool;


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

public class MyThreadPoolDemo4 {
//    参数一：核心线程数量
//    参数二：最大线程数
//    参数三：空闲线程最大存活时间
//    参数四：时间单位---TimeUnit
//    参数五：任务队列 --- 让任务在队列中等着，等有线程空闲了，再从这个队列中获取任务并执行
//    参数六：创建线程工厂 --- 按照默认的方式创建线程对象
//    参数七：任务的拒绝策略 --- 1.什么时拒绝？ 当线程池中没有空闲线程，并且队列已满时
                              //2.如何拒绝？ 拒绝策略
    public static void main(String[] args) {
        ThreadPoolExecutor pool = new ThreadPoolExecutor(2,
                5,
                2,TimeUnit.SECONDS,
                new ArrayBlockingQueue<>(10),
                Executors.defaultThreadFactory(),
                new ThreadPoolExecutor.AbortPolicy());
        for (int i = 0; i < 16; i++) {
            pool.submit(new MyRunnable());
        }

        pool.shutdown();
    }
}

2.拒绝策略

3.默认拒绝策略

package com.itheima.mythreadpool;


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

public class MyThreadPoolDemo4 {
//    参数一：核心线程数量
//    参数二：最大线程数
//    参数三：空闲线程最大存活时间
//    参数四：时间单位---TimeUnit
//    参数五：任务队列 --- 让任务在队列中等着，等有线程空闲了，再从这个队列中获取任务并执行
//    参数六：创建线程工厂 --- 按照默认的方式创建线程对象
//    参数七：任务的拒绝策略 --- 1.什么时拒绝？ 当同时需要被执行的任务 > 池子中最大的线程数量+队列的容量
                              //2.如何拒绝？ 拒绝策略
    public static void main(String[] args) {
        ThreadPoolExecutor pool = new ThreadPoolExecutor(2,
                5,
                2,TimeUnit.SECONDS,
                new ArrayBlockingQueue<>(10),
                Executors.defaultThreadFactory(),
                new ThreadPoolExecutor.AbortPolicy());
        for (int i = 0; i < 10; i++) {
            pool.submit(new MyRunnable());
        }

        pool.shutdown();
    }
}

2.6线程池-非默认任务拒绝策略【了解】

RejectedExecutionHandler是jdk提供的一个任务拒绝策略接口，它下面存在4个子类。

ThreadPoolExecutor.AbortPolicy:             丢弃任务并抛出RejectedExecutionException异常。是默认的策略。
ThreadPoolExecutor.DiscardPolicy：          丢弃任务，但是不抛出异常 这是不推荐的做法。
ThreadPoolExecutor.DiscardOldestPolicy：    抛弃队列中等待最久的任务 然后把当前任务加入队列中。
ThreadPoolExecutor.CallerRunsPolicy:        调用任务的run()方法绕过线程池直接执行。

注意：明确线程池最多可执行的任务数 = 队列容量 + 最大线程数

案例演示2：演示ThreadPoolExecutor.DiscardPolicy任务处理策略

package com.itheima.mythreadpool;


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

public class MyThreadPoolDemo5 {
//    参数一：核心线程数量
//    参数二：最大线程数
//    参数三：空闲线程最大存活时间
//    参数四：时间单位---TimeUnit
//    参数五：任务队列 --- 让任务在队列中等着，等有线程空闲了，再从这个队列中获取任务并执行
//    参数六：创建线程工厂 --- 按照默认的方式创建线程对象
//    参数七：任务的拒绝策略 --- 1.什么时拒绝？ 当提交的任务 > 池子中最大的线程数量+队列的容量
                              //2.如何拒绝？ 拒绝策略
    public static void main(String[] args) {
        ThreadPoolExecutor pool = new ThreadPoolExecutor(
                1,
                2,
                2,TimeUnit.HOURS,
                new ArrayBlockingQueue<>(1),
                Executors.defaultThreadFactory(),
                new ThreadPoolExecutor.DiscardPolicy());
        for (int i = 1; i < 5; i++) {
            int y=i;
            pool.submit(()->{
                System.out.println(Thread.currentThread().getName()+"---"+y);
            });
        }

        pool.shutdown();
    }
}

案例演示3：演示ThreadPoolExecutor.DiscardOldestPolicy任务处理策略

package com.itheima.mythreadpool;


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

public class MyThreadPoolDemo6 {
//    参数一：核心线程数量
//    参数二：最大线程数
//    参数三：空闲线程最大存活时间
//    参数四：时间单位---TimeUnit
//    参数五：任务队列 --- 让任务在队列中等着，等有线程空闲了，再从这个队列中获取任务并执行
//    参数六：创建线程工厂 --- 按照默认的方式创建线程对象
//    参数七：任务的拒绝策略 --- 1.什么时拒绝？ 当提交的任务 > 池子中最大的线程数量+队列的容量
                              //2.如何拒绝？ 拒绝策略
    public static void main(String[] args) {
        ThreadPoolExecutor pool = new ThreadPoolExecutor(
                1,
                2,
                2,TimeUnit.HOURS,
                new ArrayBlockingQueue<>(1),
                Executors.defaultThreadFactory(),
                new ThreadPoolExecutor.DiscardOldestPolicy());
        for (int i = 1; i <= 10; i++) {
            int y=i;
            pool.submit(()->{
                System.out.println(Thread.currentThread().getName()+"---"+y);
            });
        }

        pool.shutdown();
    }
}

案例演示4：演示ThreadPoolExecutor.CallerRunsPolicy任务处理策略

package com.itheima.mythreadpool;


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

public class MyThreadPoolDemo7 {
//    参数一：核心线程数量
//    参数二：最大线程数
//    参数三：空闲线程最大存活时间
//    参数四：时间单位---TimeUnit
//    参数五：任务队列 --- 让任务在队列中等着，等有线程空闲了，再从这个队列中获取任务并执行
//    参数六：创建线程工厂 --- 按照默认的方式创建线程对象
//    参数七：任务的拒绝策略 --- 1.什么时拒绝？ 当提交的任务 > 池子中最大的线程数量+队列的容量
                              //2.如何拒绝？ 拒绝策略
    public static void main(String[] args) {
        ThreadPoolExecutor pool = new ThreadPoolExecutor(
                1,
                2,
                2,TimeUnit.HOURS,
                new ArrayBlockingQueue<>(1),
                Executors.defaultThreadFactory(),
                new ThreadPoolExecutor.CallerRunsPolicy());
        for (int i = 1; i <= 10; i++) {
            int y=i;
            pool.submit(()->{
                System.out.println(Thread.currentThread().getName()+"---"+y);
            });
        }

        pool.shutdown();
    }
}

3. volatile

3.1 volatile-问题【了解】

代码分析 :

package com.itheima.myvolatile2;

public class Money {
    public static  int money = 100000;
}

package com.itheima.myvolatile2;

public class MyThread1 extends Thread {
    @Override
    public void run() {
        while (Money.money==100000) {
            
        }
        System.out.println("结婚基金已经不是十万了");
    }
}

package com.itheima.myvolatile2;

public class MyThread2 extends Thread {
    @Override
    public void run() {
        try {
            Thread.sleep(10);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        Money.money = 90000;
    }
}

程序问题 : 女孩虽然知道结婚基金是十万，但是当基金的余额发生变化的时候，女孩无法知道最新的余额。

3.2 volatile解决【重点】

1.volatile的特点：

每一次使用volatile关键字修饰的变量时，都会看一看内存中的最新值

代码实现 : 使用volatile关键字解决

package com.itheima.myvolatile;
public class Money {
    public static volatile int money = 100000;
}

package com.itheima.myvolatile;

public class MyThread1 extends  Thread {
    @Override
    public void run() {
        while (true){
            if (Money.money<10000){
                System.out.println("结婚基金已经不是十万了");
            }
        }
    }
}

package com.itheima.myvolatile;

public class MyThread2 extends Thread {
    @Override
    public void run() {
        try {
            Thread.sleep(100);
        } catch (Exception e) {
            e.printStackTrace();
        }
        Money.money=9000;
    }
}

package com.itheima.myvolatile;

public class Demo {
    public static void main(String[] args) {
        MyThread1 t1 = new MyThread1();
        t1.setName("小路同学");
        t1.start();

        MyThread2 t2 = new MyThread2();
        t2.setName("小皮同学");
        t2.start();
    }
}

3.3 synchronized解决【重点】

1.synchronized线程执行互斥代码的过程:

1 ，线程获得锁

2 ，清空变量副本

3 ，拷贝共享变量最新的值到变量副本中

4 ，执行代码

5 ，将修改后变量副本中的值赋值给共享数据

6 ，释放锁

代码实现 :

package com.itheima.myvolatile;
public class Money {
    public static volatile int money = 100000;
}

package com.itheima.myvolatile2;

public class Money {
    public static Object lock = new Object();
    public static volatile int money = 100000;
}

package com.itheima.myvolatile2;

public class MyThread1 extends  Thread {
    @Override
    public void run() {
        while(true){

                if(Money.money != 100000){
                    System.out.println("结婚基金已经不是十万了");
                    break;
                }
            }

    }
}

package com.itheima.myvolatile2;

public class MyThread2 extends Thread {
    @Override
    public void run() {
        synchronized (Money.lock) {
            try {
                Thread.sleep(10);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

            Money.money = 90000;
        }
    }
}

4.原子性

4.1 原子性【了解】

（共2点）

1.什么是原子性

所谓的原子性就是完成功能的所有操作要么都执行，要么都不执行

代码实现 :

package com.itheima.threadatom;

public class MyAtomThread implements Runnable {
    private volatile int count = 0; //送冰淇淋的数量

    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            //1,从共享数据中读取数据到本线程栈中.
            //2,修改本线程栈中变量副本的值
            //3,会把本线程栈中变量副本的值赋值给共享数据.
            count++;
            System.out.println("已经送了" + count + "个冰淇淋");
        }
    }
}


package com.itheima.threadatom;

public class AtomDemo {
    public static void main(String[] args) {
        MyAtomThread atom = new MyAtomThread();

        for (int i = 0; i < 100; i++) {
            new Thread(atom).start();
        }
    }
}

代码总结 : count++ 不是一个原子性操作, 他在执行的过程中,有可能被其他线程打断

4.2 volatile关键字不能保证原子性【了解】

1.volatile关键字不能保证原子性的原因分析

2.java中如何保证原子性操作？

使用锁
利用原子类(后面讲解)

package com.itheima.threadatom2;

public class AtomDemo {
    public static void main(String[] args) {
        MyAtomThread atom = new MyAtomThread();

        for (int i = 0; i < 100; i++) {
            new Thread(atom).start();
        }
    }
}

package com.itheima.threadatom2;

public class MyAtomThread implements Runnable {
    private volatile int count = 0; //送冰淇淋的数量
    private Object lock = new Object();

    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            //1,从共享数据中读取数据到本线程栈中.
            //2,修改本线程栈中变量副本的值
            //3,会把本线程栈中变量副本的值赋值给共享数据.
            synchronized (lock) {
                count++;
                System.out.println("已经送了" + count + "个冰淇淋");
            }
        }
    }
}

4.3 原子性_AtomicInteger 【重点】

1.什么是原子类?

原子类提供了一种用法简单，性能高效，线程安全地更新一个变量的方式

2.如何使用原子的方式更新基本类型？

使用原子的方式更新基本类型,atomic包提供了：

AtomicInteger：原子更新整型

3.AtomicInteger的常用方法：

方法	说明
public AtomicInteger()	初始化一个默认值为0的原子型Integer
public AtomicInteger(int initialValue)	初始化一个指定值的原子型Integer
int get()	获取值
int getAndIncrement()	以原子方式将当前值加1，注意，这里返回的是自增前的值。
int incrementAndGet()	以原子方式将当前值加1，注意，这里返回的是自增后的值。
int addAndGet(int data)	以原子方式将输入的数值与实例中的值（AtomicInteger里的value）相加，并返回结果
int getAndSet(int value)	以原子方式设置为newValue的值，并返回旧值

代码实现 :

package com.itheima.threadatom3;

import java.util.concurrent.atomic.AtomicInteger;

public class MyAtomIntergerDemo1 {
//    public AtomicInteger()：	               初始化一个默认值为0的原子型Integer
//    public AtomicInteger(int initialValue)： 初始化一个指定值的原子型Integer
    public static void main(String[] args) {
        AtomicInteger ac = new AtomicInteger();
        System.out.println(ac);

        AtomicInteger ac2 = new AtomicInteger(10);
        System.out.println(ac2);
    }

}

package com.itheima.threadatom3;

import java.lang.reflect.Field;
import java.util.concurrent.atomic.AtomicInteger;

public class MyAtomIntergerDemo2 {
//    int get():   		         获取值
//    int getAndIncrement():     以原子方式将当前值加1，注意，这里返回的是自增前的值。
//    int incrementAndGet():     以原子方式将当前值加1，注意，这里返回的是自增后的值。
//    int addAndGet(int data):	 以原子方式将参数与对象中的值相加，并返回结果。
//    int getAndSet(int value):  以原子方式设置为newValue的值，并返回旧值。
    public static void main(String[] args) {
//        AtomicInteger ac1 = new AtomicInteger(10);
//        System.out.println(ac1.get());

//        AtomicInteger ac2 = new AtomicInteger(10);
//        int andIncrement = ac2.getAndIncrement();
//        System.out.println(andIncrement);
//        System.out.println(ac2.get());

//        AtomicInteger ac3 = new AtomicInteger(10);
//        int i = ac3.incrementAndGet();
//        System.out.println(i);//自增后的值
//        System.out.println(ac3.get());

//        AtomicInteger ac4 = new AtomicInteger(10);
//        int i = ac4.addAndGet(20);
//        System.out.println(i);
//        System.out.println(ac4.get());

        AtomicInteger ac5 = new AtomicInteger(100);
        int andSet = ac5.getAndSet(20);
        System.out.println(andSet);
        System.out.println(ac5.get());


    }

}

4.4 AtomicInteger-内存解析【难点】

AtomicInteger原理 : 自旋锁 + CAS 算法

package com.itheima.threadatom4;

import java.util.concurrent.atomic.AtomicInteger;

public class MyAtomThread implements Runnable {
    //private volatile int count = 0; //送冰淇淋的数量
    //private Object lock = new Object();
    AtomicInteger ac = new AtomicInteger(0);

    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            //1,从共享数据中读取数据到本线程栈中.
            //2,修改本线程栈中变量副本的值
            //3,会把本线程栈中变量副本的值赋值给共享数据.
            //synchronized (lock) {
//                count++;
//                ac++;
            int count = ac.incrementAndGet();
            System.out.println("已经送了" + count + "个冰淇淋");
           // }
        }
    }
}

package com.itheima.threadatom4;

public class AtomDemo {
    public static void main(String[] args) {
        MyAtomThread atom = new MyAtomThread();

        for (int i = 0; i < 100; i++) {
            new Thread(atom).start();
        }
    }
}

4.5 AtomicInteger-源码解析【了解】

//当前主内存中的地址
private volatile int value;
//先自增，然后获取自增后的结果
public final int incrementAndGet() {
        //+ 1 自增后的结果
        //this 就表示当前的atomicInteger（值）
        //1    自增一次
        return U.getAndAddInt(this, VALUE, 1) + 1;
}

public final int getAndAddInt(Object o, long offset, int delta) {
        //v 旧值
        int v;
        //自旋的过程
        do {
            //不断的获取旧值
            v = getIntVolatile(o, offset);
            //如果这个方法的返回值为false，那么继续自旋
            //如果这个方法的返回值为true，那么自旋结束
            //o 表示的就是内存值
            //v 旧值
            //v + delta 修改后的值
        } while (!weakCompareAndSetInt(o, offset, v, v + delta));
            //作用：比较内存中的值，旧值是否相等，如果相等就把修改后的值写到内存中，返回true。表示修改成功。
            //                                 如果不相等，无法把修改后的值写到内存中，返回false。表示修改失败。
            //如果修改失败，那么继续自旋。
        return v;
}

4.6 悲观锁和乐观锁【了解】

synchronized和CAS的区别 :

相同点：在多线程情况下，都可以保证共享数据的安全性。

不同点：

synchronized总是从最坏的角度出发，认为每次获取数据的时候，别人都有可能修改。所以在每次操作共享数据之前，都会上锁。（悲观锁）

cas是从乐观的角度出发，假设每次获取数据别人都不会修改，所以不会上锁。只不过在修改共享数据的时候，会检查一下，别人有没有修改过这个数据。

如果别人修改过，那么我再次获取现在最新的值。

如果别人没有修改过，那么我现在直接修改共享数据的值.(乐观锁）

jdk1.6 synchronized(偏向锁，轻量锁(cas),重量级锁(悲观锁)) ，cas

5. 并发工具包

5.1 并发容器-Hashtable 【重点】

（共3点)

1.为什么要使用Hashtable

在集合类中HashMap是比较常用的集合对象，但是HashMap是线程不安全的(多线程环境下可能会存在问题)。为了保证数据的安全性我们可以使用Hashtable，但是Hashtable的效率低下。

2.Hashtable的原理?

3.HashTable的特点?

1.Hashtable采取悲观锁synchronized的形式保证数据的安全性

2.只要有线程访问，会将整张表全部锁起来,所以Hashtable效率低下

代码实现 :

package com.itheima.mymap;

import java.util.HashMap;
import java.util.Hashtable;

public class MyHashtableDemo {
    public static void main(String[] args) throws InterruptedException {
        Hashtable<String, String> hm = new Hashtable<>();

        Thread t1 = new Thread(() -> {
            for (int i = 0; i < 25; i++) {
                hm.put(i + "", i + "");
            }
        });


        Thread t2 = new Thread(() -> {
            for (int i = 25; i < 51; i++) {
                hm.put(i + "", i + "");
            }
        });

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

        System.out.println("----------------------------");
        //为了t1和t2能把数据全部添加完毕
        Thread.sleep(1000);

        //0-0 1-1 ..... 50- 50

        for (int i = 0; i < 51; i++) {
            System.out.println(hm.get(i + ""));
        }//0 1 2 3 .... 50


    }
}

5.2 并发容器-ConcurrentHashMap基本使用【重点】

（共3点）

1.为什么要使用ConcurrentHashMap?

为了保证数据的安全性也要考虑效率的情况下,JDK1.5以后所提供ConcurrentHashMap。

2.什么是ConcurrentHashMap？

体系结构 :

3.三种Map结构的对比

1 ，HashMap是线程不安全的。多线程环境下会有数据安全问题

2 ，Hashtable是线程安全的，但是会将整张表锁起来，效率低下

3，ConcurrentHashMap也是线程安全的，效率较高。在JDK7和JDK8中，底层原理不一样。

代码实现 :

package com.itheima.mymap;

import java.util.Hashtable;
import java.util.concurrent.ConcurrentHashMap;

public class MyConcurrentHashMapDemo {
    public static void main(String[] args) throws InterruptedException {
        ConcurrentHashMap<String, String> hm = new ConcurrentHashMap<>();

        Thread t1 = new Thread(() -> {
            for (int i = 0; i < 25; i++) {
                hm.put(i + "", i + "");
            }
        });


        Thread t2 = new Thread(() -> {
            for (int i = 25; i < 51; i++) {
                hm.put(i + "", i + "");
            }
        });

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

        System.out.println("----------------------------");
        //为了t1和t2能把数据全部添加完毕
        Thread.sleep(1000);

        //0-0 1-1 ..... 50- 50

        for (int i = 0; i < 51; i++) {
            System.out.println(hm.get(i + ""));
        }//0 1 2 3 .... 50


    }
}

5.3 并发工具类-ConcurrentHashMap1.7原理【了解】（视频19 12‘’）

3.4 并发容器-ConcurrentHashMap1.8原理【了解】（视频20 10‘’）

总结 :

1，如果使用空参构造创建ConcurrentHashMap对象，则什么事情都不做。在第一次添加元素的时候创建哈希表

2，计算当前元素应存入的索引。

3，如果该索引位置为null，则利用cas算法，将本结点添加到数组中。

4，如果该索引位置不为null，则利用volatile关键字获得当前位置最新的结点地址，挂在他下面，变成链表。

5，当链表的长度大于等于8时，自动转换成红黑树6，以链表或者红黑树头结点为锁对象，配合悲观锁保证多线程操作集合时数据的安全性

5.5 并发工具类-CountDownLatch【重点】(视频21 12‘’)

1.CountDownLatch的应用场景

让某一条线程等待其他线程执行完毕之后再执行

2.CountDownLatch类中常用的方法 :

方法	解释
public CountDownLatch(int count)	参数传递线程数，表示等待线程数量。并定义一个计数器
public void await()	让线程等待,当计数器为0时，会唤醒等待的线程
public void countDown()	当前线程执行完毕时，会将计数器-1

3.原理

CountDownLatch是通过一个计数器来实现的，计数器的初始值为需要等待线程的数量。

eg：CountDownLatch c = new CountDownLatch(10); // 等待线程的数量为10

线程调用CountDownLatch的await()方法会阻塞当前线程(即:主线程在闭锁上等待)，直到计数器的值为0。
当一个工作线程完成了自己的任务后，调用CountDownLatch的countDown()方法，计数器的值就会减1。
当计数器值为0时，说明所有的工作线程都执行完了，此时，在闭锁上等待的主线程就可以恢复执行任务

代码实现 :

package com.itheima.mycountdownlatch;

import java.util.concurrent.CountDownLatch;

public class ChileThread1 extends Thread {

    private CountDownLatch countDownLatch;
    public ChileThread1(CountDownLatch countDownLatch) {
        this.countDownLatch = countDownLatch;
    }

    @Override
    public void run() {
        //1.吃饺子
        for (int i = 1; i <= 10; i++) {
            System.out.println(getName() + "在吃第" + i + "个饺子");
        }
        //2.吃完说一声
        //每一次countDown方法的时候，就让计数器-1
        countDownLatch.countDown();
    }
}

package com.itheima.mycountdownlatch;

import java.util.concurrent.CountDownLatch;

public class ChileThread2 extends Thread {

    private CountDownLatch countDownLatch;
    public ChileThread2(CountDownLatch countDownLatch) {
        this.countDownLatch = countDownLatch;
    }
    @Override
    public void run() {
        //1.吃饺子
        for (int i = 1; i <= 15; i++) {
            System.out.println(getName() + "在吃第" + i + "个饺子");
        }
        //2.吃完说一声
        //每一次countDown方法的时候，就让计数器-1
        countDownLatch.countDown();
    }
}

package com.itheima.mycountdownlatch;

import java.util.concurrent.CountDownLatch;

public class ChileThread3 extends Thread {

    private CountDownLatch countDownLatch;
    public ChileThread3(CountDownLatch countDownLatch) {
        this.countDownLatch = countDownLatch;
    }
    @Override
    public void run() {
        //1.吃饺子
        for (int i = 1; i <= 20; i++) {
            System.out.println(getName() + "在吃第" + i + "个饺子");
        }
        //2.吃完说一声
        //每一次countDown方法的时候，就让计数器-1
        countDownLatch.countDown();
    }
}

package com.itheima.mycountdownlatch;

import java.util.concurrent.CountDownLatch;

public class MotherThread extends Thread {
    private CountDownLatch countDownLatch;
    public MotherThread(CountDownLatch countDownLatch) {
        this.countDownLatch = countDownLatch;
    }

    @Override
    public void run() {
        //1.等待
        try {
            //当计数器变成0的时候，会自动唤醒这里等待的线程。
            countDownLatch.await();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        //2.收拾碗筷
        System.out.println("妈妈在收拾碗筷");
    }
}

package com.itheima.mycountdownlatch;

import java.util.concurrent.CountDownLatch;

public class MyCountDownLatchDemo {
    public static void main(String[] args) {
        //1.创建CountDownLatch的对象，需要传递给四个线程。
        //在底层就定义了一个计数器，此时计数器的值就是3
        CountDownLatch countDownLatch = new CountDownLatch(3);
        //2.创建四个线程对象并开启他们。
        MotherThread motherThread = new MotherThread(countDownLatch);
        motherThread.start();

        ChileThread1 t1 = new ChileThread1(countDownLatch);
        t1.setName("小明");

        ChileThread2 t2 = new ChileThread2(countDownLatch);
        t2.setName("小红");

        ChileThread3 t3 = new ChileThread3(countDownLatch);
        t3.setName("小刚");

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

5.6 并发工具类-Semaphore 【重点】

1.Semaphore类的应用场景？

可以控制访问特定资源的线程数量。

2.原理

Semaphore是通过一个计数器(记录许可证的数量)来实现的，计数器的初始值为需要等待线程的数量
eg：Semaphore s = new Semaphore(10); // 线程最大的并发数为10
线程通过acquire()方法获取许可证(计数器的值减1)，只有获取到许可证才可以继续执行下去，否则阻塞当前线程
线程通过release()方法归还许可证(计数器的值加1)

代码实现 :

package com.itheima.mysemaphore;

import java.util.concurrent.Semaphore;

public class MyRunnable implements Runnable {
    //1.获得管理员对象，
    private Semaphore semaphore=new Semaphore(2) ;


    @Override
    public void run() {
        //2.获得通行证
        try {
            semaphore.acquire();
            //3.开始行驶
            System.out.println("获得了通行证开始行驶");
            Thread.sleep(2000);
            System.out.println("归还通行证");
            //4.归还通行证
            semaphore.release();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

package com.itheima.mysemaphore;

public class MySemaphoreDemo {
    public static void main(String[] args) {
        MyRunnable mr = new MyRunnable();

        for (int i = 0; i < 100; i++) {
            new Thread(mr).start();
        }
    }
}

　　　　　　　　　　　　　　　　　　　　　　　　扩展练习

题目1

请利用线程间通信, 完成连续打印1-100的数字, 要求一条线程专门打印奇数,另外一条专门用来打印偶数

要求:

1:数字打印必须是有序的,既1--100的顺序不能乱;

2:必须使用多线程技术;

效果:

........................

参考答案:

类1:

package day14.No_1;

public class Num {
    public  static int num=1;
    public  static Object look=new Object() ;
}

类2:

package day14.No_1;

public class Ji implements Runnable {

    @Override
    public void run() {
        while (true) {
            synchronized (Num.look) {
                Num.look.notifyAll();
                if (Num.num % 2 == 0) {
                    try {
                        Num.look.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                } else {
                    System.out.println("第一条线程打印奇数" + Num.num);
                    Num.num++;
                    if (Num.num == 100) {
                        return;
                    }
                }
            }
        }
    }
}

类3:

package day14.No_1;


public class Ou implements Runnable {

    @Override
    public void run() {
        synchronized (Num.look) {
            while (true) {
                synchronized (Num.look) {
                    Num.look.notifyAll();
                    if (Num.num%2 == 1) {
                        try {
                            Num.look.wait();
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    } else {
                        System.out.println("第二条线程打印偶数" + Num.num);
                        Num.num++;
                        if (Num.num == 101) {
                            return;
                        }
                    }
                }
            }
        }
    }
}

测试类:

package day14.No_1;

public class Test {
    public static void main(String[] args) {
        Ji j = new Ji();
        Ou o = new Ou();
        new Thread(j).start();
        new Thread(o).start();
    }
}

运行效果:

题目2

假如某班级有10人,早晨老师来到教室之后,需要等待10位学生都到齐了才会开始上课,如果10位学生还没有到齐,老师需要一直等待;假如把老师和每一个学生都看成是一个独立的线程,请使用代码模拟这个老师上课的场景;

要求:

1:老师上课之前,打印老师准备就绪,等所有学生到齐之后,老师打印开始讲课;

2:只有10个学生都到了,老师才可以上课;

效果:

参考答案:

学生类:

package day14.No_2;

import java.util.concurrent.CountDownLatch;

public class Student implements Runnable {
    private CountDownLatch countDownLatch;

    public Student(CountDownLatch countDownLatch) {
        this.countDownLatch = countDownLatch;
    }

    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName() + "到了");
        countDownLatch.countDown();
    }
}

教师类:

package day14.No_2;

import java.util.concurrent.CountDownLatch;

public class Teacher implements Runnable {
    private CountDownLatch countDownLatch;

    public Teacher(CountDownLatch countDownLatch) {
        this.countDownLatch = countDownLatch;
    }

    @Override
    public void run() {
        System.out.println("准备讲课");
        try {
            countDownLatch.await();
            System.out.println("开始上课");
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

    }
}

测试类:

package day14.No_2;

import java.util.concurrent.CountDownLatch;

public class Test {
    public static void main(String[] args) {
        CountDownLatch countDownLatch = new CountDownLatch(10);
        Teacher teachertast = new Teacher(countDownLatch);
        Student studenttast = new Student(countDownLatch);
        for (int i = 1; i <= 10; i++) {
            new Thread(studenttast, "学生" + i).start();
        }
        new Thread(teachertast).start();

    }
}

运行效果:

题目3[业务比较复杂,有难度呦]

假如现在有一辆公交车,车上有两个乘务员,一个专门负责让乘客上车,并提示目前车上的人数,另一个乘务员专门负责乘客下车,并提示乘客下车后,目前车上的人数,请使用代码模拟这个场景;

要求:

1:公交车最多乘坐30位乘客,如果超过30人,则上车的乘务员不再安排乘客上车,会一直等待,直到车上有空位子再安排乘客上车;

2:如果车上乘客数量为0了,则不再乘客下车,直到车上有乘客,再继续安排乘客下车;

3:每次上下车的人数采用随机数的方式表示上车的人数和下车的人数,且上车时,1次最多上当前最大空余座位数,最少是1人,下车时,1次最多下当前车上总乘客数,最少是1人;

效果:

参考答案:

类1:

package day14.No_3;

public class Chengwu {
    public static int count = 30;
    public static Object lock = new Object();
}

类2:

package day14.No_3;

import java.util.Random;

public class GetOff implements Runnable {
    @Override
    public void run() {
        while (true) {
            synchronized (Chengwu.lock) {
                if (Chengwu.count <= 0) {
                    try {
                        Chengwu.lock.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                } else {
                    Random random = new Random();
                    int num = random.nextInt(Chengwu.count) + 1;
                    Chengwu.count -= num;
                    System.out.println("下去了" + num + "车上剩余" + Chengwu.count + "人");
                    Chengwu.lock.notifyAll();
                }
            }
        }
    }
}

类3:

package day14.No_3;

import java.util.Random;

public class GetOn implements Runnable {
    @Override
    public void run() {
        while (true) {
            synchronized (Chengwu.lock) {
                if (Chengwu.count >= 30) {
                    try {
                        Chengwu.lock.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                } else {
                    Random random = new Random();
                    int num = random.nextInt(30 - Chengwu.count) + 1;
                    Chengwu.count += num;
                    System.out.println("上去了" + num + "人,还剩下" + Chengwu.count);
                    Chengwu.lock.notifyAll();
                }
            }
        }
    }
}

测试类:

package day14.No_3;

public class Test {
    public static void main(String[] args) {
        GetOn getOn = new GetOn();
        GetOff getOff = new GetOff();
        Thread t1 = new Thread(getOn);
        Thread t2 = new Thread(getOff);
        t1.start();
        t2.start();
    }
}

运行效果:

查看全文

相关阅读:
js-js系列-数据类型-概念
 js-基础总结3
js-基础总结2
js-基础总结1
js-面试题
 webpack-模块化
 js-对象常用方法
 js-事件冒泡-事件捕获-事件委托
 js-call aplly bind2
aioxs实现token无感刷新

原文地址：https://www.cnblogs.com/859630097com/p/14227582.html

Java进阶: 多线程线程状态?为什么使用线程池?如何创建线程池?如何解决线程安全?线程安全-可见性,线程安全-原子性,并发容器注意特点.并发工具类

重难点梳理

知识点梳理

学习目标

超详细讲义

==知识点==

1. 线程状态介绍 【记忆】

2.线程池

2.1 线程池-基本原理 【难点】

2.2 线程池-Executors默认线程池 【了解】

2.3 线程池-Executors创建指定上限的线程池 【了解】

2.4 线程池-ThreadPoolExecutor 【重点】

2.5 线程池-参数详解 【难点】

2.6线程池-非默认任务拒绝策略 【了解】

3. volatile

3.1 volatile-问题 【了解】

3.2 volatile解决 【重点】

3.3 synchronized解决 【重点】

4.原子性

4.1 原子性 【了解】

4.2 volatile关键字不能保证原子性【了解】

4.3 原子性_AtomicInteger 【重点】

4.4 AtomicInteger-内存解析【难点】

4.5 AtomicInteger-源码解析【了解】

4.6 悲观锁和乐观锁【了解】

5. 并发工具包

5.1 并发容器-Hashtable 【重点】

5.2 并发容器-ConcurrentHashMap基本使用【重点】

5.3 并发工具类-ConcurrentHashMap1.7原理 【了解】（视频19 12‘’）

3.4 并发容器-ConcurrentHashMap1.8原理【了解】（视频20 10‘’）

5.5 并发工具类-CountDownLatch【重点】(视频21 12‘’)

5.6 并发工具类-Semaphore 【重点】

扩展练习

题目1

题目2

题目3[业务比较复杂,有难度呦]

　　　　　　　　　　　　　　　　　　　　　　　　　　重难点梳理

　　　　　　　　　　　　　　　　　　　　　　　　知识点梳理

　　　　　　　　　　　　　　　　　　　　　　　　学习目标

　　　　　　　　　　　　　　　　　　　　　　　　超详细讲义

1. 线程状态介绍【记忆】

2.1 线程池-基本原理【难点】

2.2 线程池-Executors默认线程池【了解】

2.3 线程池-Executors创建指定上限的线程池【了解】

2.5 线程池-参数详解【难点】

2.6线程池-非默认任务拒绝策略【了解】

3.1 volatile-问题【了解】

3.2 volatile解决【重点】

3.3 synchronized解决【重点】

4.1 原子性【了解】

5.3 并发工具类-ConcurrentHashMap1.7原理【了解】（视频19 12‘’）

　　　　　　　　　　　　　　　　　　　　　　　　扩展练习