JavaSE基础知识梳理——多线程并发

10.1 基本概念

  • 进程之间内存不共享

  • Java中线程间堆内存和方法区共享，栈内存独立（很重要），方法区只有1块，堆也只有1块，栈可能有多个，主线程对应主栈，在进程中创建的变量或对象的引用位于栈中，不共享。（多个进程间不共享局部变量）

  • 每个栈与每个栈之间之间互不干扰，各自执行，这就是多线程并发。

  • 堆，栈，方法区

  • image-20200606002653497.png

  • 线程的生命周期：

    NEW：创建

    RUNNABLE：启动线程之后，被唤醒之后，有被CPU调度的机会

    WAITING：进入等待集

    WAITINGTIME：带阻塞时间的等待

    RUNNING：运行态

    BLOCKING：阻塞态

    TERMINATED：死亡态

  • 线程的运行由CPU调度，每一次运行结束的位置由程序计数器计算，下一次从上一次断开的位置继续。

10.2 创建线程的方法

  • 创建线程的方法有很多种：
  1. extends Thread，重写run()方法
MyThread t = new MyThread()
  1. implements Runnable，重写run()方法。==Runnable只是一个普通接口==
Runnable r = new MyRunnable();
Thread t = new Thread(r);
  1. implements Callable，重写call方法。==Callable也只是一个普通接口==
Callable c = new MyCallable();
//用FutureTask去接收Callable，FutureTask是一个有返回值的线程，因为call()方法有返回值
FutureTask f = new FutureTask(c);
f.run();
f.get();//get是一个阻塞性方法，会一直获取。也可以指定等待时间
  1. 传入一个线程Thread1，==Thread类实现了Runnable接口==
Thread t = new Thread(Thread1)
  1. 传入 FutureTask，==FutureTask实现了RunnableFuture接口，RunnableFuture继承至Runnable==
Thread t = new Thread(new FutureTask(new Callable(){重写call()方法}))
  1. 线程池ThreadPoolExecutor，在后面介绍
  2. 线程组ThreadGroup

10.3 线程的常用方法

  • 开启线程

    //Thread类
void start();
//FutureTask类
Object run();

    注意如果直接调用run()方法不会开启线程。

  • 设置守护线程

//守护线程会等待到所有用户线程结束后自动结束
void setDeamon(true);
  • 中断，设置中断标志
/*设置中断标志并不会中断线程，如果处于wait,sleep,join等阻塞态被中断时，会抛出InterruptedException异常
。在catch到异常之后，中断标志重置为false*/
void interrupt();
Thread t ;
t.interrupt();
  • 检测中断的两个方法
//静态方法
Thread.interrupted();//检测当前线程中断标志位，如果为true，则返回true并重置为false。
//实例方法
void isInterrupted();//检测中断标志，不重置
  • 阻塞线程的方法
1.void sleep(long timeMills);//挂起线程持续timeMills时间，单位毫秒
2.void wait()
  void wait(long timeMills) //需要先获取锁，synchronized，然后用该锁执行wait()，线程将自己挂起并释放锁
3.void join() //将调用者加到当前线程，等待调用者执行完毕。
  • 唤醒线程，使线程重新回到Runnable态
//唤醒线程也要先获取锁,synchronized，并且用和wait相同的锁去notify
void notify()//随机唤醒单个线程
void notifyAll()//唤醒所有在等待中的线程，只会唤醒在调用notifyAll之前就处于等待的线程。

==notify造成死锁的原因分析==

​ 假如有消费者C1和C2，生产者P1，C1先拿到锁，发现没有产品，就wait，然后释放锁，锁被P1拿到了，就产品+1，然后notify，然后下一次争抢锁，P1抢到了，发现有产品，就wait，然后释放锁，锁被C1或者C2拿到了，消费，然后notify，释放锁，再一次抢夺锁时，只有消费者抢到了，则它就会wait，这把锁只要被消费者抢到，因为没有产品，就只能wait。就进入了死锁。即只要生产者连续两次拿到锁，必然会生产产品，然后第二次将自己挂起，后面只要消费者消费了之后唤醒的不是生产者，就会使得所有消费者都获得锁，然后把自己挂起。最终进入死锁。

所以结论是，所有生产者和消费者用notifyAll一定不会死锁，因为这样会唤醒所有挂起的线程，不存在忽略了生产者而造成后续的死锁。死锁产生的根本原因是生产者只唤醒生产者，消费者只唤醒消费者，最终生产者都认为满了，然后挂起；消费者消费完了，唤醒别的消费者，别的消费者就会挂起，直到最先的消费者被挂起。而如果都是用notifyAll，就不分差异的唤醒所有

  • 让出CPU执行权
void yield();//让出当前的CPU执行权，让CPU重新调度，有可能再次被调度到
  • 设置线程优先级
void setPriority();//默认等级5，最高10，最低1。优先级越高，被调度到的概率越大

10.4 线程同步

  • 线程同步是解决线程安全问题的方法，主要有==synchronized==同步，==Lock==同步和==CAS非阻塞算法==同步。CPU效率依次递增

1、synchronized关键字

  • synchronized作用于方法内

    //synchronized(lock)，lock一般是共享的资源，虽然用其他唯一的实例也可以，但是推荐用共享资源
@override
public void run(){
    synchronized(lock){
        //do something
    }
}

    • synchronized作用于方法上

      1.实例方法
public synchronized void method(){} //此时的锁为this，实例对象

2.静态方法
public synchronized static void method(){} //此时的锁为类锁，class，它是唯一的

2、volatile关键字

  • volatile只保存内存可见性，它不保证线程安全
  • volatile修饰的变量在发生变化时，会及时通知其它线程，重新从主内存中取值到工作内存。但是因为volatile不是原子性操作，因此存在线程安全。
  • image-20200606114713038.png
  • 总线嗅探机制：线程A修改信息后在汇编指令中会加Lock前缀，修改信息通过总线被线程B嗅探到，（因为cpu和内存的交互通过I\O总线），此时B就把原来内存空间的变量变为无效状态。重新从主内存中读取。
  • volatile不保证线程安全的原因：

因为线程A在引擎从工作内存中拿到值之后，读，改是分步的，这时候如果另外一个线程B已经完成了写到主内存的操作，假如写入的值为2。这时候线程A会通过嗅探机制，感知到volatile修改的值的变化，会将自己工作内存的变量舍去，置位无效，但是引擎已经读取了值了，并且完成了值的修改，假如修改为了1。这时候，引擎就会assgin，把值存到工作内存，然后再写到主内存，就会将原来主内存的值给覆盖了。

3、Lock锁

  • java.util.concurrent.locks包下的Lock是一个接口，其常用实现类为ReentrantLock，效率比synchronized高，更安全
  • Lock锁也只有释放了才能被其它线程获取到。
  • ==ReentrantLock==
//它是一个独占锁
new ReentrantLock(boolean fair);//fair表示是否公平
    公平：先到先得
    不公平：先到不一定先得，随机，默认是不公平

常用方法:

//ReentrantLock类
void lock();//上锁
void unlock();//释放锁

boolean tryLock(long time,TimeUnit timeUnit);//尝试获取锁，成功则返回true，失败则在规定的时间内多次尝试
Condition newCondition();//获取Condition对象，这个对象有await()和signal,signallAll方法，相当于wait和notify，notifyAll

//Condition类
void await();//相当于wait()
void await(int timeMills);//相当于wait(int timeMills)
void signal();
void signalAll();

示例：

while (true){
    if (lock.tryLock(2, TimeUnit.SECONDS)){
            lock.lock;
        try {
            System.out.println("我获取到锁了");
        }finally {
            lock.unlock();
            break;
        }
    }
}

class TaskQueue {
    private final Lock lock = new ReentrantLock();
    private final Condition condition = lock.newCondition();
    private Queue<String> queue = new LinkedList<>();


    public void addTask(String s) {
        lock.lock();
        try {
            queue.add(s);
            condition.signalAll();
        } finally {
            lock.unlock();
        }
    }


    public String getTask() {
        lock.lock();
        try {
            while (queue.isEmpty()) {
                condition.await();
            }
            return queue.remove();
        } finally {
            lock.unlock();
        }
    }
}

  • ==ReentrantReadWriteLock==

    //读写锁，写的优先级高于读。
读写锁，多个线程可以同时获得读锁，但写锁是独占的，这样的好处是提高并发效率。适用于多个线程读，少数线程写。且没有写的情况下，才能读。这是一种悲观锁。
读锁和写锁本质上是同一个锁，只是读锁可以共享。所以在读的过程中也要加锁，防止被写占有，导致读的过程中数据变更引起脏读
//示例
public class Counter {
    private final ReadWriteLock rwlock = new ReentrantReadWriteLock();
    private final Lock rlock = rwlock.readLock();
    private final Lock wlock = rwlock.writeLock();
    private int[] counts = new int[10];


    public void inc(int index) {
        wlock.lock(); // 加写锁
        try {
            counts[index] += 1;
        } finally {
            wlock.unlock(); // 释放写锁
        }
    }


    public int[] get() {
        rlock.lock(); // 加读锁
        try {
            return Arrays.copyOf(counts, counts.length);
        } finally {
            rlock.unlock(); // 释放读锁
        }
    }
}
    • ==StampledLock==

    这是一种乐观锁，允许在读的时候写，性能比ReentrantReadWriteLock高

4、JUC包下的原子类

  • Atomic类采用的是CAS非阻塞算法，使用的是Unsafe类的compareAndSwap()作为基础。Unsafe类下还有很多其它方法，参考==《并发编程之美》==。

  • CAS是机器级别的指令，效率比加锁的方式高。

  • 并发包分类：

    1. 其中LongBinaryOperator中的left就是每次accumulate运算后的结果，第一次计算时是构造LongAccumulator时传入的identity，right是accumulate传入的参数。
    2. LongAdder和LongAccumulator是相对于Atomic类而言，它们类似ThreadLocal，每个线程都有一个自己的复制变量，不需要再为了竞争原子资源而消耗时间。
    3. 原子类和锁的不同之处在于锁是阻塞的，只能被一个线程只有，其它线程都必须阻塞等待。而原子类不会阻塞线程，只不过同一时间只有一个线程可以操作成功。
image-20200606121302916.png

10.5 ThreadLocal和ThreadLocalRandom

1、ThreadLocal类

  • ThreadLocal<T>是本地线程变量，它是一个泛型类，可以存储任意类型。每个线程都有一个ThreadLocal的复制。互不影响。==但是必须先在自己的虚拟机栈里set这个值==。一般定义为==static==，最后要在==finally里清除ThreadLocal==。
  • 常用方法
void set();
Object get();
void remove()清除

2、ThreadLocalRandom类

  • ThreadLocalRandom是多线程下使用的Random随机数类。
ThreadLocalRandom.current()//获取当前线程的ThreadLocalRandom对象。

10.6 线程池

1、基本概念

  • 线程池和线程组：

    在main方法中自定义的线程都属于同一个线程组，同一个线程组共享变量，但是线程组使用较少。

    线程池的效率高，它降低了创建线程的开销。

  • 线程池的关系

==主要接口视图关系==:

Executor：线程池的顶级接口

ExecutorService：线程池的真正接口

ScheduledExecutorService：需要执行重复任务的线程池的接口

ThreadPoolExecutor：ExecutorService的默认实现类

ScheduledThreadPooleExecutor：继承至ThreadPoolExecturo，实现ScheduledExecutorService接口

如果要执行非重复任务，就转为ExecutorServiece，如果要执行重复任务，就转为ScheduledExecutorService。

image-20200606124629735.png
  • 工具类

==Executors==提供一些静态工厂，用于创建不同类型的线程池。

  • 线程池的一些参数

    ==corePoolSize==：核心线程数量
    ==maximumPooleSize==：最大线程数量

    ==keepAliveTime==：线程没有任务时，最多保存多长时间后会终止

2、线程池分类

  • ==newCachedThreadPool==
//创建一个带有缓冲的线程池，缓冲的意思是可以动态调整线程池的核心线程数量，当超过了默认大小时，就扩容。可以人为指定一个区间。
ExecutorService service = Executors.newCachedThreadPool(); //线程池，无大小限制
  • ==newFixedThreadPool==
//创建一个指定大小的线程池
ExecutorService service = Executors.newFixedThreadPool(2);
  • ==newSingleThreadPoolExecutor==
//创建一个单线程的线程池，线程是串行执行任务
ExecutorService service = Executors.newSingleThreadExecutor()
//单线程的执行顺序，先执行t1再t2，再t3，相当于固定大小为1
service.execute(t1);
service.execute(t2);
service.execute(t3);

  • ==newScheduledThreadPool==

    //周期性的执行任务
ExecutorService service = Executors.newScheduledThreadPool();
service.schedule(t1,2, TimeUnit.SECONDS);//延迟多久执行，只执行一次，一次性任务
service.scheduleAtFixedRate(t1,1,2,TimeUnit.SECONDS);//任务，第一次执行的时间，间隔多久执行一次，时间单位
service.scheduleWithFixedDelay(t1,1,2,TimeUnit.SECONDS);//任务，第一次执行的时间，间隔多久执行一次，时间单位
service.shutdown();//关闭线程池
    scheduleAtFixedRate 间隔多久就执行一次，从任务一开始就计时，不管上一次任务是否执行完毕。但是如果该任务的执行时间大于周期，那么后续任务可能会延迟开始，但是不会并发执行
    scheduleWithFixedDelay 间隔多久执行一次，指的是等上一次任务执行完毕，再间隔多久，执行

    • 线程池的执行任务方法：

      //submit
Object submit(Callable<T> callable);//适用于有返回值的线程，虽然也可以接收Runnable，这是返回的是null，但是为了区分，最好接收Callable。

//execute
void execute(Runnable runnable);//执行无返回值的线程
©著作权归作者所有,转载或内容合作请联系作者
  • 人面猴
    序言：七十年代末，一起剥皮案震惊了整个滨河市，随后出现的几起案子，更是在滨河造成了极大的恐慌，老刑警刘岩，带你破解...
    沈念sama阅读 210,914评论 6赞 490
  • 死咒
    序言：滨河连续发生了三起死亡事件，死亡现场离奇诡异，居然都是意外死亡，警方通过查阅死者的电脑和手机，发现死者居然都...
    沈念sama阅读 89,935评论 2赞 383
  • 救了他两次的神仙让他今天三更去死
    文/潘晓璐 我一进店门，熙熙楼的掌柜王于贵愁眉苦脸地迎上来，“玉大人，你说我怎么就摊上这事。” “怎么了？”我有些...
    开封第一讲书人阅读 156,531评论 0赞 345
  • 道士缉凶录：失踪的卖姜人
    文/不坏的土叔 我叫张陵，是天一观的道长。 经常有香客问我，道长，这世上最难降的妖魔是什么？ 我笑而不...
    开封第一讲书人阅读 56,309评论 1赞 282
  • 港岛之恋（遗憾婚礼）
    正文 为了忘掉前任，我火速办了婚礼，结果婚礼上，老公的妹妹穿的比我还像新娘。我一直安慰自己，他们只是感情好，可当我...
    茶点故事阅读 65,381评论 5赞 384
  • 恶毒庶女顶嫁案：这布局不是一般人想出来的
    文/花漫 我一把揭开白布。 她就那样静静地躺着，像睡着了一般。 火红的嫁衣衬着肌肤如雪。 梳的纹丝不乱的头发上，一...
    开封第一讲书人阅读 49,730评论 1赞 289
  • 城市分裂传说
    那天，我揣着相机与录音，去河边找鬼。 笑死，一个胖子当着我的面吹牛，可吹牛的内容都是我干的。 我是一名探鬼主播，决...
    沈念sama阅读 38,882评论 3赞 404
  • 双鸳鸯连环套：你想象不到人心有多黑
    文/苍兰香墨 我猛地睁开眼，长吁一口气：“原来是场噩梦啊……” “哼！你这毒妇竟也来了？” 一声冷哼从身侧响起，我...
    开封第一讲书人阅读 37,643评论 0赞 266
  • 万荣杀人案实录
    序言：老挝万荣一对情侣失踪，失踪者是张志新（化名）和其女友刘颖，没想到半个月后，有当地人在树林里发现了一具尸体，经...
    沈念sama阅读 44,095评论 1赞 303
  • 护林员之死
    正文 独居荒郊野岭守林人离奇死亡，尸身上长有42处带血的脓包…… 初始之章·张勋 以下内容为张勋视角 年9月15日...
    茶点故事阅读 36,448评论 2赞 325
  • 白月光启示录
    正文 我和宋清朗相恋三年，在试婚纱的时候发现自己被绿了。 大学时的朋友给我发了我未婚夫和他白月光在一起吃饭的照片。...
    茶点故事阅读 38,566评论 1赞 339
  • 活死人
    序言：一个原本活蹦乱跳的男人离奇死亡，死状恐怖，灵堂内的尸体忽然破棺而出，到底是诈尸还是另有隐情，我是刑警宁泽，带...
    沈念sama阅读 34,253评论 4赞 328
  • 日本核电站爆炸内幕
    正文 年R本政府宣布，位于F岛的核电站，受9级特大地震影响，放射性物质发生泄漏。R本人自食恶果不足惜，却给世界环境...
    茶点故事阅读 39,829评论 3赞 312
  • 男人毒药：我在死后第九天来索命
    文/蒙蒙 一、第九天 我趴在偏房一处隐蔽的房顶上张望。 院中可真热闹，春花似锦、人声如沸。这庄子的主人今日做“春日...
    开封第一讲书人阅读 30,715评论 0赞 21
  • 一桩弑父案，背后竟有这般阴谋
    文/苍兰香墨 我抬头看了看天上的太阳。三九已至，却和暖如春，着一层夹袄步出监牢的瞬间，已是汗流浃背。 一阵脚步声响...
    开封第一讲书人阅读 31,945评论 1赞 264
  • 情欲美人皮
    我被黑心中介骗来泰国打工， 没想到刚下飞机就差点儿被人妖公主榨干…… 1. 我叫王不留，地道东北人。 一个月前我还...
    沈念sama阅读 46,248评论 2赞 360
  • 代替公主和亲
    正文 我出身青楼，却偏偏与公主长得像，于是被迫代替她去往敌国和亲。 传闻我的和亲对象是个残疾皇子，可洞房花烛夜当晚...
    茶点故事阅读 43,440评论 2赞 348