JAVA多线程

最新推荐文章于 2020-10-02 12:21:40 发布

原来是肖某人

最新推荐文章于 2020-10-02 12:21:40 发布

阅读量177

点赞数 1

分类专栏： JAVA基础文章标签： java 多线程并发编程 thread

本文链接：https://blog.csdn.net/qq_33905217/article/details/106069825

版权

JAVA基础专栏收录该内容

36 篇文章 0 订阅

订阅专栏

6.7 suspend()和resume()

8.3.1 CAS(Compare and Swap 比较并交换)

8.3.2 AQS

8.4 小结

1.线程状态

附上Thread类中注释说明

NEW：初始态，指一个线程被创建为实例但是还没有开始任何逻辑执行。
RUNABLE：可运行状态，指的是线程开始执行的一个状态。但是这个执行分为两个部分：就绪态（ready）和运行态（runing）。其中就绪态指的是线程已经开始但未获得CPU时间片，所以是一个不在运行状态，而运行态则是指线程争得时间片开始执行run方法中的逻辑。
BLOCKED：线程阻塞态，指线程开始争夺临界资源使用权时未获得锁，程序会进入阻塞状态，等待锁被释放后继续争夺。
WATTING：等待状态，指线程无限等待的一个状态，除非被notify()/notifyAll()唤醒。常用的为wait()、join()
TIMED_WATTING：超时等待，指线程有时间限制的等待状态，等到时间结束即重新进入就绪态。常用的有sleep(time)、wait(time)、join()
TERMINATED：终止，线程执行完毕，释放资源销毁。

2.线程开辟

线程开辟通常有两者方式：

继承Thread
实现Runable接口

2.1继承Thread类

事实上，我们所继承的Thread类也是实现了Runable接口

如下图所示是Thread类中的截图：

下面进行继承Therad类的实现

class MyThread extends Thread{
    @Override
    public void run() {
        for (int i=0;i<10;i++){
            System.out.println(i);
        }
    }
}

2.2实现Runable接口

我们的Thread其实也实现了Runable接口，那么我们Runable接口中到底有什么呢？

附上Runable接口的接口图：

我们可以看到Runable中只有一个run方法，而这个run方法我们在上边继承Thread类时也重写过。
这个run方法是什么呢，其实润方法中存储的是我们希望产生并发执行的一个逻辑方法，我们需要开启多线程执行就必须实现run方法。

下面是具体的Runable接口实现

2.2.1 匿名实现

Thread t1 = new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i=0;i<10;i++){
                    System.out.println(i);
                }
            }
        });

2.2.2 lambda实现

 Runnable r2 =  ()->{
            for (int i=0;i<10;i++){
                System.out.println(i);
            }
        };
Thread t2 = new Thread(r2);
t2.start();

2.2.3 直接实现接口

 Runnable r = new Runnable() {
            @Override
            public void run() {
                for (int i=0;i<10;i++){
                    System.out.println(i);
                }
            }
        };
 Thread t3 = new Thread(r);

3.线程常规操作

3.1 线程命名

//构造方法命名
Thread t4 = new Thread("Thread4");

//setter函数命名
Thread t5 = new Thread();
t5.setName("Thread5");

3.2 优先级设置

作用：设置线程优先级只是改变了线程获得时间片的一个概率，并不意味着优先级高的一定先执行。

如何设置线程优先级

//设置优先级
Thread t6 = new Thread();
t6.setPriority(6);

注意

优先级的设置是一个[0,10]的整数。默认为5。
设置优先级必须在线程开始之前

4.线程转换

借用Java 并发编程的艺术》图一张

5.引起线程状态转换的方法

5.1 Thread.sleep()

线程状态从RUNABLE中的运行态转化到超时等待状态，一旦超时，重新返回就绪态。

 Runnable r = new Runnable() {
            @Override
            public void run() {
                for (int i=0;i<10;i++){
                    try {
                        Thread.sleep(10000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(i);
                }
            }
        };
        Thread t3 = new Thread(r);

6.2yield()

指的是让当前线程释放CPU时间片重新回到就绪态。然后重新开始时间片的争夺。
注意：yield只是释放CPU时间片，所以下次获得时间片后会继续从上次yield的地方往后继续执行

//yield
        Runnable r3 = new Runnable() {
            @Override
            public void run() {
                for (int i=0;i<10;i++){
                    Thread.yield();
                    System.out.println(i);
                }
            }
        };
        Thread t7 = new Thread(r3);

6.3 wait()

当前线程释放自己的锁标记，让出CPU，使得当前线程进入等待队列

注意：释放锁标记但是当wait的线程被唤醒后会重新竞争之前放弃的锁，当竞争到锁时，会从之前wait的地方直接继续向后执行。

package day5_12;


import java.util.concurrent.*;

/**
 * @author 50422
 */
public class ThreadPoolTest {
    public static void main(String[] args) {

        /*ExecutorService service = new ThreadPoolExecutor(3,5, TimeUnit.SECONDS,);*/

        Runnable r1 = ()->{
            SynchronizedTest.fun1();
        };
        Runnable r2 = ()->{
            SynchronizedTest.fun2();
        };

        Thread t1 = new Thread(r1,"t1");
        Thread t2 = new Thread(r2,"t2");

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

class SynchronizedTest{

    static int i=10;

    public static void fun1(){
        synchronized ("A"){

            System.out.println(Thread.currentThread().getName()+"获得A锁");


            try{
                "A".wait();
            }catch (Exception e){
                System.out.println(e.getMessage());
            }
            synchronized ("B"){
                System.out.println(Thread.currentThread().getName()+"获得B锁");
            }
        }
    }

    public static void fun2(){
        synchronized ("B"){
            System.out.println(Thread.currentThread().getName()+"获得B锁");
            synchronized ("A"){
                System.out.println(Thread.currentThread().getName()+"获得A锁");
                "A".notify();
            }
        }
    }
}

6.4 notify()

唤醒等待队列中的一个等待目标锁标记的线程（随机），使这个线程进入锁池

6.5 notifyAll()

唤醒所以等待队列中所有等待目标锁对象的线程，使它们进入锁池

6.6 interrupt()

功能：为当前线程打上中断标记。
注意：打上中断标记并不意味着要中断线程，所以如果我们需要中断线程可以设置一个终端标记判断，为true时跳出循环或return方法。

package day5_12;

/**
 * @author 50422
 */
public class InterruptTest {
    public static void main(String[] args) {
        Runnable r1 = ()->{
            for(int i=0;i<20;i++){
                System.out.println(i);
                if(i==10){
                    Thread.currentThread().interrupt();
                    System.out.println("线程中断标志"+Thread.currentThread().isInterrupted());
                }
            }
            System.out.println("线程中断标志"+Thread.interrupted());
        };

        Thread t1 = new Thread(r1);
        t1.start();
    }
}

Thread.interrupted()：判断当前线程中断标记，并将其改回false。

Thread.currentThread().isInterrupted()：判断当前线程中断标记，不修改中断标记。

6.7 suspend()和resume()

不建议使用，基本舍弃了。虽然它可以做到所谓的线程暂停。

原因如下：

容易造成同步对象被独占：当我有一个线程占用同步资源时发生暂停，那么在被resume()之前该线程所占用的资源将没有线程可以访问。
导致数据不同步：当我有一个线程在修改临界资源时发生暂停，我们无法保证整个修改已经完成，如果只修改了一般却发生了暂停，那么其他线程在访问时拿到的数据就会与暂停线程恢复后修改的数据出现差异。

详细可以访问：

独占：https://www.jianshu.com/p/a075800838e8

数据不同步：https://www.jianshu.com/p/03f9b7cf8c07

6.8 stop()

不建议使用，基本舍弃了。虽然它可以做到所谓的线程暂停。

原因：

线程不安全：对使用stop()，是因为它不安全。它会解除由线程获取的所有锁定，当在一个线程对象上调用stop()方法时，这个线程对象所运行的线程就会立即停止，假如一个线程正在执行：synchronized void { x = 3; y = 4;}　由于方法是同步的，多个线程访问时总能保证x,y被同时赋值，而如果一个线程正在执行到x = 3;时，被调用了 stop()方法，即使在同步块中，它也干脆地stop了，这样就产生了不完整的残废数据。而多线程编程中最最基础的条件要保证数据的完整性，所以请忘记线程的stop方法，以后我们再也不要说“停止线程”了。而且如果对象处于一种不连贯状态，那么其他线程能在那种状态下检查和修改它们。结果很难检查出真正的问题所在。

https://blog.csdn.net/zwz2011303359/article/details/66487714

7.临界资源

概述：被多个线程共享的资源叫做临界资源。

7.1 临界资源问题

//临界资源演示
        Runnable r4 = ()->{
            while(Ticket.tickets>0) {
                System.out.println(Thread.currentThread().getName() + "卖出一张票,剩余:" + Ticket.tickets--);
                try {
                    Thread.sleep(300);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }

        };
        Thread s1 = new Thread(r4,"售票员1");
        Thread s2 = new Thread(r4,"售票员2");
        Thread s3 = new Thread(r4,"售票员3");
        Thread s4 = new Thread(r4,"售票员4");

        s1.start();
        s2.start();
        s3.start();
        s4.start();

class Ticket{
    public static int tickets= 100;
}

运行结果：

上述买票问题我们会发现多个线程之间在卖票时余票出现了问题。

原因：

因为多个线程对同一个操作数操作时由于时间差的问题，他们的操作并不会出现同步，而是不断多次将自己计算出的参数对原值进行覆盖。

解决这个问题：

引入锁的概念，确保同一时间数据只能被一个线程操作

8.锁

8.1 简介

8.1.1 什么是锁

锁时作为并发共享数据，保证一致性的工具。

8.1.2 锁的作用

对临界资源进行上锁，同一时间只有获得锁的线程才能操作该临界资源（另一种说法：确保线程同步）。

8.1.3 锁如何起作用

因为不同线程访问临界资源时存在先后顺序，所以当引入锁之后，先访问的线程会对资源进行上锁，而其他线程必须等待该线程执行完毕后释放资源才能进行争夺。

8.2 锁的种类

公平锁/非公平锁
可重入锁
独享锁/共享锁
互斥锁/读写锁
乐观锁/悲观锁
分段锁
偏向锁/轻量级锁/重量级锁
自旋锁

上面是很多锁的名词，这些分类并不是全是指锁的状态，有的指锁的特性，有的指锁的设计，下面总结的内容是对每个锁的名词进行一定的解释。

8.2.1公平锁/非公平锁

公平锁是指多个线程按照申请锁的顺序来获取锁。
非公平锁是指多个线程获取锁的顺序并不是按照申请锁的顺序，有可能后申请的线程比先申请的线程优先获取锁。有可能，会造成优先级反转或者饥饿现象。
对于Java ReentrantLock而言，通过构造函数指定该锁是否是公平锁，默认是非公平锁。非公平锁的优点在于吞吐量比公平锁大。
//设置为公平锁
ReentrantLock lock = new ReentrantLock(true);
对于synchronized而言，也是一种非公平锁。由于其并不像ReentrantLock是通过AQS的来实现线程调度，所以并没有任何办法使其变成公平锁。

8.2.2 可重入锁

可重入锁又名递归锁，是指在同一个线程在外层方法获取锁的时候，在进入内层方法会自动获取锁。对于Java ReentrantLock而言, 其名字是Re entrant Lock即是重新进入锁。对于synchronized而言，也是一个可重入锁。可重入锁的一个好处是可一定程度避免死锁。

首先ReentrantLock和NonReentrantLock都继承父类AQS，其父类AQS中维护了一个同步状态status来计数重入次数，status初始值为0。

当线程尝试获取锁时，可重入锁先尝试获取并更新status值，如果status == 0表示没有其他线程在执行同步代码，则把status置为1，当前线程开始执行。如果status != 0，则判断当前线程是否是获取到这个锁的线程，如果是的话执行status+1，且当前线程可以再次获取锁。而非可重入锁是直接去获取并尝试更新当前status的值，如果status != 0的话会导致其获取锁失败，当前线程阻塞。

释放锁时，可重入锁同样先获取当前status的值，在当前线程是持有锁的线程的前提下。如果status-1 == 0，则表示当前线程所有重复获取锁的操作都已经执行完毕，然后该线程才会真正释放锁。而非可重入锁则是在确定当前线程是持有锁的线程之后，直接将status置为0，将锁释放。

要点：

可重入锁的一个优点是可一定程度避免死锁
AQS通过控制status状态来判断锁的状态，对于非可重入锁状态不是0则去阻塞；对于可重入锁如果是0则执行，非0则判断当前线程是否是获取到这个锁的线程，是的话把status状态＋1，释放的时候，只有status为0，才将锁释放

关于可重入锁的详细解释来自链接：https://www.jianshu.com/p/e25983256448
package com.test.reen;

// 演示可重入锁是什么意思，可重入，就是可以重复获取相同的锁，synchronized和ReentrantLock都是可重入的
// 可重入降低了编程复杂性
public class WhatReentrant {
	public static void main(String[] args) {
		new Thread(new Runnable() {
			@Override
			public void run() {
				synchronized (this) {
					System.out.println("第1次获取锁，这个锁是：" + this);
					int index = 1;
					while (true) {
						synchronized (this) {
							System.out.println("第" + (++index) + "次获取锁，这个锁是：" + this);
						}
						if (index == 10) {
							break;
						}
					}
				}
			}
		}).start();
	}
}

//原代码链接：https://blog.csdn.net/w8y56f/article/details/89554060
8.2.3 独占锁/共享锁

独占锁是指该锁一次只能被一个线程所持有；共享锁是指该锁可被多个线程所持有。

对于Java ReentrantLock而言，其是独占锁。但是对于Lock的另一个实现类ReadWriteLock，其读锁是共享锁，其写锁是独占锁。读锁的共享锁可保证并发读是非常高效的，读写、写读、写写的过程是互斥的。独占锁与共享锁也是通过AQS来实现的，通过实现不同的方法，来实现独占或者共享。对于synchronized而言，当然是独占锁。

ReadWriteLock具体代码使用可以参考https://www.jianshu.com/p/4b45f9a1f7d2

8.2.4 互斥锁/读写锁

上面说到的独享锁/共享锁就是一种广义的说法，互斥锁/读写锁就是具体的实现。互斥锁在Java中的具体实现就是ReentrantLock；读写锁在Java中的具体实现就是ReadWriteLock。

8.2.5 乐观锁/悲观锁

乐观锁与悲观锁不是指具体的什么类型的锁，而是指看待并发同步的角度。

悲观锁：总是假设最坏的情况，每次去拿数据的时候都认为别人会修改，所以每次在拿数据的时候都会上锁，这样别人想拿这个数据就会阻塞直到它拿到锁。比如Java里面的同步原语synchronized关键字的实现就是悲观锁。

乐观锁：顾名思义，就是很乐观，每次去拿数据的时候都认为别人不会修改，所以不会上锁，但是在更新的时候会判断一下在此期间别人有没有去更新这个数据，可以使用版本号等机制。乐观锁适用于多读的应用类型，这样可以提高吞吐量，在Java中java.util.concurrent.atomic包下面的原子变量类就是使用了乐观锁的一种实现方式CAS(Compare and Swap 比较并交换)实现的。

8.2.6 分段锁

分段锁其实是一种锁的设计，并不是具体的一种锁，对于ConcurrentHashMap而言，其并发的实现就是通过分段锁的形式来实现高效的并发操作，ConcurrentHashMap中的分段锁称为Segment，它即类似于HashMap（JDK7与JDK8中HashMap的实现）的结构，即内部拥有一个Entry数组，数组中的每个元素又是一个链表；同时又是一个ReentrantLock（Segment继承了ReentrantLock)。当需要put元素的时候，并不是对整个HashMap进行加锁，而是先通过hashcode来知道他要放在那一个分段中，然后对这个分段进行加锁，所以当多线程put的时候，只要不是放在一个分段中，就实现了真正的并行的插入。但是，在统计size的时候，可就是获取HashMap全局信息的时候，就需要获取所有的分段锁才能统计。

分段锁的设计目的是细化锁的粒度，当操作不需要更新整个数组的时候，就仅仅针对数组中的一项进行加锁操作。

8.2.7 自旋锁

在Java中，自旋锁是指尝试获取锁的线程不会立即阻塞，而是采用循环的方式去尝试获取锁，这样的好处是减少线程上下文切换的消耗，缺点是循环会消耗CPU。

8.2.8 偏向锁/轻量级锁/重量级锁

这三种锁是指锁的状态，并且是针对synchronized。在Java 5通过引入锁升级的机制来实现高效synchronized。这三种锁的状态是通过对象监视器在对象头中的字段来表明的。

偏向锁是指一段同步代码一直被一个线程所访问，那么该线程会自动获取锁。降低获取锁的代价。

轻量级锁是指当锁是偏向锁的时候，被另一个线程所访问，偏向锁就会升级为轻量级锁，其他线程会通过自旋的形式尝试获取锁，不会阻塞，提高性能。

重量级锁是指当锁为轻量级锁的时候，另一个线程虽然是自旋，但自旋不会一直持续下去，当自旋一定次数的时候，还没有获取到锁，就会进入阻塞，该锁膨胀为重量级锁。重量级锁会让其他申请的线程进入阻塞，性能降低。
本章主要内容来自于https://blog.csdn.net/tyyj90/article/details/78236053

8.3 锁机制CAS/AQS

8.3.1 CAS(Compare and Swap 比较并交换)

CAS(Compare And Swap)，即比较并交换。是解决多线程并行情况下使用锁造成性能损耗的一种机制，CAS操作包含三个操作数——内存位置（V）、预期原值（A）和新值(B)。如果内存位置的值与预期原值相匹配，那么处理器会自动将该位置值更新为新值。否则，处理器不做任何操作。无论哪种情况，它都会在CAS指令之前返回该位置的值。CAS有效地说明了“我认为位置V应该包含值A；如果包含该值，则将B放到这个位置；否则，不要更改该位置，只告诉我这个位置现在的值即可。

JAVA对CAS的支持：

在JDK1.5中新增java.util.concurrent包就是建立在CAS之上的。相对于对于synchronized 这种阻塞算法，CAS是非阻塞算法的一种常见实现。所以java.util.concurrent在性能上有了很大的提升。

以java.util.concurrent包中的AtomicInteger为例，看一下在不使用锁的情况下是如何保证线程安全的。主要理解 getAndIncrement方法，该方法的作用相当于 ++i 操作。

public class AtomicInteger extends Number implements java.io.Serializable {  
    private volatile int value; 

    public final int get() {  
        return value;  
    }  
    // 获取当前值current，并设置新值为current+1
    public final int getAndIncrement() {  
        for (;;) {  
            int current = get();  
            int next = current + 1;  
            if (compareAndSet(current, next))  
                return current;  
        }  
    }  
    // 原子的设置新值为update, expect为期望的当前的值
    public final boolean compareAndSet(int expect, int update) {  
        return unsafe.compareAndSwapInt(this, valueOffset, expect, update);  
    }  
}

8.3.2 AQS

概述：
AQS：AbstractQuenedSynchronizer抽象的队列式同步器。是除了java自带的synchronized关键字之外的锁机制.
这个类在java.util.concurrent.locks包

AQS的核心思想：如果被请求的共享资源空闲，则将当前请求资源的线程设置为有效的工作线程，并将共享资源设置为锁定状态，如果被请求的共享资源被占用，那么就需要一套线程阻塞等待以及被唤醒时锁分配的机制
AQS维护了一个volatile int state（代表共享资源）和一个FIFO线程等待队列（多线程争用资源被阻塞时会进入此队列）。state的访问方式有三种:

getState()
setState()
compareAndSetState()

AQS定义两种资源共享方式：Exclusive（独占，只有一个线程能执行，如ReentrantLock）和Share（共享，多个线程可同时执行，如Semaphore/CountDownLatch）。

不同的自定义同步器争用共享资源的方式也不同。自定义同步器在实现时只需要实现共享资源state的获取与释放方式即可，至于具体线程等待队列的维护（如获取资源失败入队/唤醒出队等），AQS已经在顶层实现好了。自定义同步器实现时主要实现以下几种方法：

isHeldExclusively()：该线程是否正在独占资源。只有用到condition才需要去实现它。
tryAcquire(int)：独占方式。尝试获取资源，成功则返回true，失败则返回false。
tryRelease(int)：独占方式。尝试释放资源，成功则返回true，失败则返回false。
tryAcquireShared(int)：共享方式。尝试获取资源。负数表示失败；0表示成功，但没有剩余可用资源；正数表示成功，且有剩余资源。
tryReleaseShared(int)：共享方式。尝试释放资源，如果释放后允许唤醒后续等待结点返回true，否则返回false。

一般来说，自定义同步器要么是独占方法，要么是共享方式，他们也只需实现tryAcquire-tryRelease、tryAcquireShared-tryReleaseShared中的一种即可。但AQS也支持自定义同步器同时实现独占和共享两种方式，如ReentrantReadWriteLock。

8.4 小结

本文引用：https://blog.csdn.net/tyyj90/article/details/78236053

原来是肖某人

关注

1
点赞
踩
1

收藏

觉得还不错? 一键收藏
打赏
0
评论
JAVA多线程

目录1.线程状态2.线程开辟2.1继承Thread类2.2实现Runable接口2.2.1 匿名实现2.2.2 lambda实现2.2.3 直接实现接口3.线程常规操作3.1 线程命名3.2 优先级设置4.线程转换5.引起线程状态转换的方法5.1 Thread.sleep()6.2yield()6.3 wait()6.4 notify()6.5 notifyAll()6.6 interrupt()6.7 suspend()和res.
复制链接

扫一扫