并发编程基础知识

最新推荐文章于 2024-07-13 13:55:40 发布

Mr.sleepy

最新推荐文章于 2024-07-13 13:55:40 发布

阅读量95

点赞数

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

本文链接：https://blog.csdn.net/weixin_44726656/article/details/104512517

版权

JAVA 专栏收录该内容

2 篇文章 0 订阅

订阅专栏

一，线程相关的必备基础知识

线程安全:一个类被多个线程以任意方式同时调用，且不需要额外部署，同步和协同的情况下，仍然保证内部数据正确且表现正确的行为，那么这个类就是线程安全的。

常见的安全的类列举:AtomicInteger 原子操作的Integer变量

不改变对象一定是线程安全的，比如final修饰的不可变类，比如String,Integer等。再比如枚举类（枚举类内部是final的）。

二，线程的同步异步，阻塞和非阻塞

同步是阻塞式的调用，调用方必须等待响应方执行完毕才会返回。

大多数非异步场景不用异步就用同步来调用，在编排的流程中必须等待拿到响应结果才去做下一步操作，且在实时联络中相互之间有串联或关联数据的。

异步是非阻塞式的调用，立即返回调用方无需等待响应方返回，实际结果响应方会通过状态通知或回调来告知调用方。

三，异步的使用场景

第一是耗时任务，主线程中提交耗时任务到线程池，然后通过future来异步获取任务执行结果。

第二是电商下单，链路的非核心链路调用未来下单的性能，考虑将订单下发的发货仓库等非实时流程放在后续操作，提高下单的响应速度。比如这里交易系统通过消息自发自接等方式来驱动后续流程。
同步异步的比较

四、同步异步
同步异步关注点是得到结果的方式，同步是实时返回结果，异步是通过共享变量，通知消息或回调得到结果。

阻塞与非阻塞关注点在程序在等待调用结果返回同时的状态。

五、程序的并发和并行

单线程定义：程序行的过程中始终只有一个线程在运行，后面的代码段必须等到前面代码段的任务执行完毕后才能执行，这样的程序可以认为是单线程程序。

多线程定义：程序由多个线程构成，方法内各代码块执行顺序是不确定的，这样的程序可以认为是多线程程序。比如使用executors线程池的时候，线程的执行顺序是不确定的。

并发和并行都是多线程下的概念。

并发指的是逻辑上是同时的但是，实际上并不是同时的只是不同时间段在处理不同的线程。例如单处理器处理多线程任务。

并行是实际上同时处理。通常是多个处理器。

六、线程的状态

1、new 被创建，但是还未开始使用

2、runnable 表示线程在可运行状态或者说处于正在被执行的状态，还处在等待处理器等资源的状态。

3、blocked 阻塞状态，标志正在等待监视器，等待进入同步代码块。

4、waiting状态由于调用了一些方法

Thread.sleep()      Object.wait()    Thread.join()    等方法。

5、time_waiting 定时等待状态

6、terminated 终止线程的状态，线程已经执行完毕。

线程运行状态示意图
七、几个线程的方法介绍

1、Thread.yield( )
Java线程中的Thread.yield( )方法，译为线程让步。顾名思义，就是说当一个线程使用了这个方法之后，它就会把自己CPU执行的时间让掉，

让自己或者其它的线程运行，注意是让自己或者其他线程运行，并不是单纯的让给其他线程。

  yield()的作用是让步。它能让当前线程由“运行状态”进入到“就绪状态”，从而让其它具有相同优先级的等待线程获取执行权；但是，并不能保

证在当前线程调用yield()之后，其它具有相同优先级的线程就一定能获得执行权；也有可能是当前线程又进入到“运行状态”继续运行！

  举个例子：一帮朋友在排队上公交车，轮到Yield的时候，他突然说：我不想先上去了，咱们大家来竞赛上公交车。然后所有人就一块冲向公交车，

有可能是其他人先上车了，也有可能是Yield先上车了。

 但是线程是有优先级的，优先级越高的人，就一定能第一个上车吗？这是不一定的，优先级高的人仅仅只是第一个上车的概率大了一点而已，

最终第一个上车的，也有可能是优先级最低的人。并且所谓的优先级执行，是在大量执行次数中才能体现出来的。下面是一个示例。

public class MainTest {
    public static void main(String[] args) {
        newThread("ThreadA").start();
        newThread("ThreadB").start();
    }

    public static Thread newThread (String threadName){
        return new Thread(()->{
            for(int i = 0; i < 20; i++){
                System.out.println(Thread.currentThread().getName()+":"+i);
                if(i == 10){
                    Thread.yield();
                }
            }
        },threadName);
    }
}

运行结果：

ThreadA:0
ThreadA:1
ThreadA:2
ThreadA:3
ThreadA:4
ThreadA:5
ThreadA:6
ThreadA:7
ThreadA:8
ThreadA:9
ThreadA:10
ThreadB:0
ThreadB:1
ThreadB:2
ThreadB:3
ThreadB:4
ThreadB:5
ThreadB:6
ThreadB:7
ThreadB:8
ThreadB:9
ThreadB:10
ThreadA:11
ThreadA:12
ThreadA:13
ThreadA:14
ThreadA:15
ThreadA:16
ThreadA:17
ThreadA:18
ThreadA:19
ThreadB:11
ThreadB:12
ThreadB:13
ThreadB:14
ThreadB:15
ThreadB:16
ThreadB:17
ThreadB:18
ThreadB:19

再次运行：

ThreadB:0
ThreadB:1
ThreadB:2
ThreadB:3
ThreadB:4
ThreadB:5
ThreadB:6
ThreadB:7
ThreadB:8
ThreadB:9
ThreadB:10
ThreadB:11
ThreadB:12
ThreadB:13
ThreadB:14
ThreadB:15
ThreadB:16
ThreadB:17
ThreadB:18
ThreadB:19
ThreadA:0
ThreadA:1
ThreadA:2
ThreadA:3
ThreadA:4
ThreadA:5
ThreadA:6
ThreadA:7
ThreadA:8
ThreadA:9
ThreadA:10
ThreadA:11
ThreadA:12
ThreadA:13
ThreadA:14
ThreadA:15
ThreadA:16
ThreadA:17
ThreadA:18
ThreadA:19

这里可以看出yield()仅仅是让出时间片来公平竞争，但竞争的结果也是不确定的。

2、Thread.sleep()
线程休眠，主动让出CPU ,但是不会让出持有的当前锁。
例如：

public class MainTest {
    private static Object object = new Object();
    public static void main(String[] args) {
        newThreadSleep("ThreadA").start();
        newThreadSleep("ThreadB").start();
        System.out.println("主线程...");
    }
    
    public static Thread newThreadSleep (String threadName){
        return new Thread(()->{
            synchronized (object) {
                for (int i = 0; i < 20; i++) {
                    System.out.println(Thread.currentThread().getName() + ":" + i);
                    if (i == 10) {
                        System.out.println(Thread.currentThread().getName() + ":" + i);
                        try {
                            System.out.println(Thread.currentThread().getName() + "准备休眠..");
                            Thread.sleep(1000L);
                            System.out.println(Thread.currentThread().getName() + "完成休眠..");
                        } catch (Exception e) {
                            e.printStackTrace();
                        }
                    }
                }
            }
        },threadName);
    }
 }

执行结果为：

主线程...
ThreadA:0
ThreadA:1
ThreadA:2
ThreadA:3
ThreadA:4
ThreadA:5
ThreadA:6
ThreadA:7
ThreadA:8
ThreadA:9
ThreadA:10
ThreadA:10
ThreadA准备休眠..
ThreadA完成休眠..
ThreadA:11
ThreadA:12
ThreadA:13
ThreadA:14
ThreadA:15
ThreadA:16
ThreadA:17
ThreadA:18
ThreadA:19
ThreadB:0
ThreadB:1
ThreadB:2
ThreadB:3
ThreadB:4
ThreadB:5
ThreadB:6
ThreadB:7
ThreadB:8
ThreadB:9
ThreadB:10
ThreadB:10
ThreadB准备休眠..
ThreadB完成休眠..
ThreadB:11
ThreadB:12
ThreadB:13
ThreadB:14
ThreadB:15
ThreadB:16
ThreadB:17
ThreadB:18
ThreadB:19

可以看出sleep()方法只是不会放开持有的锁，线程A休眠期间线程B没有获得锁也无法执行，处于阻塞状态。
3、Thread,join()方法

public class ThreadJoin {
    public static void main(String[] args) {
        Thread threadA = newThread("ThreadA");
        Thread threadB = newThread("ThreadB");

        threadA.start();
        threadB.start();

        try {
            threadA.join();
            System.out.println("等待线程A执行完毕...");
            threadB.join();
            System.out.println("等待线程B执行完毕...");
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        System.out.println("主线程继续执行...");

    }

    public static Thread newThread (String threadName){
        return new Thread(()->{
            for(int i = 0; i < 5; i++){
                System.out.println(Thread.currentThread().getName()+":"+i);
                if(i == 2){
                    try {
                        Thread.sleep(1000L);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        },threadName);
    }
}

执行结果：

ThreadA:0
ThreadA:1
ThreadA:2
ThreadB:0
ThreadB:1
ThreadB:2
ThreadA:3
ThreadA:4
等待线程A执行完毕...
ThreadB:3
ThreadB:4
等待线程B执行完毕...
主线程继续执行...

由结果可以看到，当A线程调用join()方法的时候，线程A会先执行完毕（之后没有线程A的内容的输出，表示执完了），之后去执行线程B。
4、Object.wait()
该方法调用前必须拥有对象锁，例如在synchronied代码块内调用wait()方法后对象锁会释放，线程处于waiting状态。简而言之就是处于wait状态的线程会释放锁。之后重新获取锁开始运行。期间锁被其他的线程拿走可以继续执行。

public class ObjectWait {
    public static Object lock = new Object();

    public static void main(String[] args) {
       newThread("ThreadA").start();
       newThread("ThreadB").start();

        try {
            System.in.read();
        } catch (IOException e) {
            e.printStackTrace();
        }

    }

    public static Thread newThread (String threadName) {
        return new Thread(() -> {
            synchronized (lock) {
                for (int i = 0; i < 5; i++) {
                    lock.notifyAll();
                    System.out.println(Thread.currentThread().getName() + ":" + i);
                    try {
                        System.out.println(Thread.currentThread().getName() + "wait开始");
                        lock.wait();
                        System.out.println(Thread.currentThread().getName() + "wait结束");
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        }, threadName);
    }
}

结果：

ThreadA:0
ThreadAwait开始
ThreadB:0
ThreadBwait开始
ThreadAwait结束
ThreadA:1
ThreadAwait开始
ThreadBwait结束
ThreadB:1
ThreadBwait开始
ThreadAwait结束
ThreadA:2
ThreadAwait开始
ThreadBwait结束
ThreadB:2
ThreadBwait开始
ThreadAwait结束
ThreadA:3
ThreadAwait开始
ThreadBwait结束
ThreadB:3
ThreadBwait开始
ThreadAwait结束
ThreadA:4
ThreadAwait开始
ThreadBwait结束
ThreadB:4
ThreadBwait开始
ThreadAwait结束

八、线程的死锁和避免
死锁是指两个或者两个以上的进程在执行过程中由于竞争资源或者或者由于彼此通信而造成的一种阻塞现象，若无外力作用他们都将无法推进下去，此时称系统处于死锁状态或者系统产生了死锁，这些永远在互相等待的进程成为死锁进程。
真实原因是两个或两个以上的线程抢占两把或者以上的锁，抢占的顺序不不一致。线程A拥有了锁1，等待拥有锁2，线程B拥有锁2等待拥有锁1，这样相互等待对方的锁，从而造成死锁。

如何避免死锁呢？
1、不使用锁，或者不使用两把或者两把以上的锁
2、当必须使用两把以及两把以上的时候要确保获取锁的顺序是一样的。
3、尝试获取具有超时释放的锁，例如Lock中的tryLock()
4、当发生了java-level的死锁的时候重启程序干掉进程或线程。
下面给一个例子

public class DeadLock {
    private static Object objectLock = new Object();
    private static String stringLock = new String();

    public static void main(String[] args) {
        newThread("ThreadA",objectLock,stringLock).start();
        newThread("ThreadB",stringLock,objectLock).start();

        try {
            System.in.read();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

 private static Thread newThread(String threadName,Object lockFirst, Object lockSecond){
        return new Thread(()->{
            synchronized (lockFirst){
                System.out.println(Thread.currentThread().getName()+" hoding lockFirst");
                try {
                    Thread.sleep(3000L);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName()+" waiting lockSecond");
                synchronized (lockSecond){
                    System.out.println(Thread.currentThread().getName()+" hoding lockSecond");
                }
            }
        },threadName);
    }
    
}

执行结果：

ThreadA hoding lockFirst
ThreadB hoding lockFirst
ThreadA waiting lockSecond
ThreadB waiting lockSecond

那么如何避免死锁呢，使用方法2，来尝试，讲获取锁的顺序保持一致。执行结果为：

ThreadA hoding lockFirst
ThreadA waiting lockSecond
ThreadA hoding lockSecond
ThreadB hoding lockFirst
ThreadB waiting lockSecond
ThreadB hoding lockSecond

那么当程序死锁的时候如何定位呢？
输入命令：jps
拿到PID
再通过运行：jstack PID
查看线程的运行状态。
jps:列举正在运行的虚拟机进程，并显示虚拟机执行的主类以及这些进程的唯一ID.
jstack :用于JVM当前时刻的进程快照，得到JVM当前每一条线程正在执行的堆栈信息，定位线程长时间卡顿问题，如死锁，死循环等。
查找阻塞的线程
补充一个数据库死锁的问题产生的原因是一样的，只不过锁换成了开启事务。

Mr.sleepy

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
并发编程基础知识

一，线程相关的必备基础知识线程安全:一个类被多个线程以任意方式同时调用，且不需要额外部署，同步和协同的情况下，仍然保证内部数据正确且表现正确的行为，那么这个类就是线程安全的。常见的安全的类列举:AtomicInteger 原子操作的Integer变量不改变对象一定是线程安全的，比如final修饰的不可变类，比如String,Integer等。再比如枚举类（枚举类内部是final的）。二...
复制链接

扫一扫