线程平安与不平安

线程平安：当多线程拜访时，采纳了加锁的机制；即当一个线程拜访该类的某一个数据时，会对这个数据进行爱护，其余线程不能对其拜访，直到该线程读取完结之后，其余线程才能够应用。防止出现数据不统一或者数据被净化的状况。
线程不平安：多个线程同时操作某个数据，呈现数据不统一或者被净化的状况。

代码示例：

package thread_5_10;

public class Demo26 {
    static  int  a = 0;
    public static void main(String[] args) throws InterruptedException {

        Thread t1 = new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < 100_0000; i++) {
                    a++;
                }
            }
        });

        Thread t2 = new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < 100_0000; i++) {
                    a--;
                }
            }
        });

        //开启线程
        t1.start();
        t2.start();

        //期待线程实现
        //t1.join();
        //t2.join();
        while(t1.isAlive() || t2.isAlive()){

        }
        System.out.println(a);
    }
}

运行后果：

后果剖析：

集体整顿了一些材料，有须要的敌人能够间接点击支付。

[Java基础知识大全](https://jq.qq.com/?_wv=1027&k…
)

[22本Java架构师外围书籍](https://jq.qq.com/?_wv=1027&k…
)

[从0到1Java学习路线和材料](https://jq.qq.com/?_wv=1027&k…
)

[1000+道2021年最新面试题](https://jq.qq.com/?_wv=1027&k…

线程不平安的因素：

CPU是抢占式执行的（抢占资源）
多个线程操作的是同一个变量
可见性
非原子性
编译期优化（指令重排）

volatile

volatile是指令关键字，作用是确保本指令不会因编译期优化而省略，且每次要求间接读值。能够解决内存不可见和指令重排序的问题，然而不能解决原子性问题

解决线程不平安

有两种加锁形式：

synchronized(jvm层的解决方案）
Lock手动锁

synchronized

操作锁的流程

尝试获取锁a
应用锁（这一步骤是具体的业务代码）
开释锁
synchronized是JVM层面锁的解决方案，它帮咱们实现了加锁和开释锁的过程

代码示例

package thread_5_10;

public class Demo31 {
    //循环的最大次数
    private final static int maxSize = 100_0000;

    //定义全局变量
    private static int number = 0;

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

        //申明锁对象
        Object obj = new Object();

        Thread t1 = new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < maxSize; i++) {
                    //实现加锁
                    synchronized (obj){
                        number++;
                    }

                }
            }
        });

        t1.start();

        Thread t2 = new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < maxSize; i++) {
                    synchronized (obj){
                        number--;
                    }

                }
            }
        });

        t2.start();

        //期待两个线程执行实现
        t1.join();
        t2.join();

        System.out.println(number);
    }
}

运行后果：

解析：

留神

synchronized实现分为：

操作系统层面，它是依附互斥锁mutex
针对JVM，monitor实现
针对Java语言来说，是将锁信息寄存在对象头中

三种应用场景

应用synchronized润饰代码块，（能够对任意对象加锁）
应用synchronized润饰静态方法（对以后类进行加锁）
应用synchronized润饰一般办法（对以后类实例进行加锁）
润饰静态方法：

package thread_5_10;

public class Demo32 {

    private static int number = 0;
    private static final int maxSize = 100_0000;

    public static void main(String[] args) throws InterruptedException {
        Thread t1 = new Thread(new Runnable() {
            @Override
            public void run() {
                increment();
            }
        });
        t1.start();

        Thread t2 = new Thread(new Runnable() {
            @Override
            public void run() {
                decrement();
            }
        });
        t2.start();

        t1.join();
        t2.join();
        System.out.println("最终后果为："+number);
    }

    public synchronized static void increment(){
        for (int i = 0; i < maxSize; i++) {
            number++;
        }
    }

    public synchronized static void decrement(){
        for (int i = 0; i < maxSize; i++) {
            number--;
        }
    }
}

润饰实例办法：

package thread_5_10;

public class Demo33 {

    private static int number = 0;
    private static final int maxSize = 100_0000;

    public static void main(String[] args) throws InterruptedException {
        Demo33 demo = new Demo33();
        Thread t1 = new Thread(new Runnable() {
            @Override
            public void run() {
                demo.increment();
            }
        });
        t1.start();

        Thread t2 = new Thread(new Runnable() {
            @Override
            public void run() {
                demo.decrement();
            }
        });
        t2.start();

        t1.join();
        t2.join();
        System.out.println("最终后果："+number);
    }

    public synchronized  void increment(){
        for (int i = 0; i < maxSize; i++) {
            number++;
        }
    }

    public synchronized  void decrement(){
        for (int i = 0; i < maxSize; i++) {
            number--;
        }
    }
}

Lock手动锁

代码示例：

package thread_5_10;

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class Demo34 {

    private static int number = 0;
    private static final int maxSize = 100_0000;

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

        //创立lock实例
        Lock lock = new ReentrantLock();

        Thread t1 = new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < maxSize; i++) {
                    lock.lock();
                    try{
                        number++;
                    }finally {
                        lock.unlock();
                    }
                }
            }
        });
        t1.start();

        Thread t2 = new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < maxSize; i++) {
                    lock.lock();
                    try{
                        number--;
                    }finally {
                        lock.unlock();
                    }
                }
            }
        });
        t2.start();

        t1.join();
        t2.join();
        System.out.println("最终后果为-->   "+number);
    }
}

运行后果：

最终后果为-->   0

注意事项：

lock（）肯定要放在try里面

如果放在try外面，如果try外面出现异常，还没有加锁胜利就执行finally外面的开释锁的代码，就会出现异常
如果放在try外面，如果没有锁的状况下开释锁，这个时候产生的异样就会把业务代码外面的异样给吞噬掉，减少代码调试的难度

偏心锁与非偏心锁

偏心锁：当一个线程开释锁之后，须要被动唤醒“须要失去锁”的队列来失去锁
非偏心锁：当一个线程开释锁之后，另一个线程刚好执行到获取锁的代码就能够间接获取锁
java语言中，所有锁的默认实现形式都是非偏心锁

1.synchronized是非偏心锁
2.reentrantLock默认是非偏心锁，但也能够显示地申明为偏心锁

显示申明偏心锁格局：

ReentrantLock源码：

示例一：

package thread_5_10;

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

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

        Lock lock = new ReentrantLock(true);

        Thread t1 = new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < 100; i++) {
                    lock.lock();
                    try{
                        System.out.println("线程1");
                    }finally {
                        lock.unlock();
                    }
                }
            }
        });



        Thread t2 = new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < 100; i++) {
                    lock.lock();
                    try{
                        System.out.println("线程2");
                    }finally {
                        lock.unlock();
                    }
                }
            }
        });

        Thread.sleep(1000);
        t1.start();
        t2.start();

    }
}

运行后果：

示例二：

package test;

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

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

        Lock lock = new ReentrantLock(true);

        Runnable r = new Runnable() {
            @Override
            public void run() {
                for(char ch: "ABCD".toCharArray()){
                    lock.lock();
                    try{
                        System.out.print(ch);
                    }finally {
                        lock.unlock();
                    }
                }
            }
        };

        Thread.sleep(100);
        Thread t1 = new Thread(r);
        Thread t2 = new Thread(r);
        t1.start();
        t2.start();
    }
}

运行后果：

AABBCCDD

两种锁区别

synchronized和lock的区别

关键字不同
synchronized主动进行加锁和开释锁，而Lock须要手动加锁和开释锁
synchronized是JVM层面上的实现，而Lock是Java层面锁的实现
润饰范畴不同，synchronized能够润饰代码块，静态方法，实例办法，而Lock只能润饰代码块
synchronized锁的模式是非偏心锁，而lock锁的模式是偏心锁和非偏心锁
Lock的灵活性更高

死锁

死锁定义

在两个或两个以上的线程运行中，因为资源抢占而造成线程始终期待的问题

当线程1领有资源并1且试图获取资源2和线程2领有了资源2，并且试图获取资源1的时候，就发了死锁

死锁示例

package thread_5_11;

public class Demo36 {
    public static void main(String[] args) {
        //申明加锁的资源
        Object lock1 = new Object();
        Object lock2 = new Object();

        Thread t1 = new Thread(new Runnable() {
            @Override
            public void run() {
                //获取线程名称
                String threadName = Thread.currentThread().getName();

                //1.获取资源1
                synchronized (lock1){
                    System.out.println(threadName+" 获取到了lock1");
                    try {

                        //2.期待1ms，让线程t1和线程t2都获取到相应的资源
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(threadName+" waiting lock2");

                    //3.获取资源2
                    synchronized (lock2){
                        System.out.println(threadName+" 获取到了lock2");
                    }
                }
            }
        },"t1");
        t1.start();

        Thread t2 = new Thread(new Runnable() {
            @Override
            public void run() {
                String threadName = Thread.currentThread().getName();
                synchronized (lock2){
                    System.out.println(threadName+" 获取到了lock2");
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(threadName+" waiting lock1");
                    synchronized (lock1){
                        System.out.println(threadName+" 获取到了lock1");
                    }
                }
            }
        },"t2");

        t2.start();
    }
}

运行后果：

通过工具来查看死锁：
（1）jdk–>bin–>jconsole.exe

（2）jdk–>bin–>jvisualvm.exe

（3）jdk–>bin–>jmc.exe

死锁的4个必要条件

1.互斥条件：当资源被一个线程领有之后，就不能被其余的线程领有了
2.占有且期待：当一个线程领有了一个资源之后又试图申请另一个资源
3.不可抢占：当一个资源被一个线程被领有之后，如果不是这个线程被动开释此资源的状况下，其余线程不能领有此资源
4.循环期待：两个或两个以上的线程在领有了资源之后，试图获取对方资源的时候造成了一个环路

线程通信

所谓的线程通信就是在一个线程中的操作能够影响另一个线程，wait（休眠线程），notify（唤醒一个线程），notifyall（唤醒所有线程）

wait办法

注意事项：
1.wait办法在执行之前必须先加锁。也就是wait办法必须配合synchronized配合应用
2.wait和notify在配合synchronized应用时，肯定要应用同一把锁

运行后果：

wait之前
主线程唤醒t1
wait之后

多线程

package thread_5_13;

public class demo40 {
    public static void main(String[] args) throws InterruptedException {
        Object lock = new Object();
        Thread t1 = new Thread(new Runnable() {
            @Override
            public void run() {
                //调用wait办法之前必须先加锁
                synchronized (lock){
                    try {
                        System.out.println("t1 wait之前");
                        lock.wait();
                        System.out.println("t1 wait之后");

                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }

            }
        },"t1");


        Thread t2 = new Thread(new Runnable() {
            @Override
            public void run() {
                //调用wait办法之前必须先加锁
                synchronized (lock){
                    try {
                        System.out.println("t2 wait之前");
                        lock.wait();
                        System.out.println("t2 wait之后");

                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }

            }
        },"t2");

        Thread t3 = new Thread(new Runnable() {
            @Override
            public void run() {
                //调用wait办法之前必须先加锁
                synchronized (lock){
                    try {
                        System.out.println("t3 wait之前");
                        lock.wait();
                        System.out.println("t3 wait之后");

                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }

            }
        },"t3");

        t1.start();
        t2.start();
        t3.start();
        Thread.sleep(1000);
        System.out.println("主线程调用唤醒操作");

        //在主线程中唤醒
        synchronized (lock){
            lock.notify();
        }
    }
}

运行后果：

t1 wait之前
t2 wait之前
t3 wait之前
主线程调用唤醒操作
t1 wait之后

注意事项：

将lock.notify（）批改为lock.notifyAll（），则三个线程都能被唤醒
wait在不传递任何参数的状况下会进入waiting状态（参数为0也是waiting状态）；当wait外面有一个大于0的整数时，它就会进入timed_waiting状态
对于wait和sleep开释锁的代码：

wait在期待的时候能够开释锁，sleep在期待的时候不会开释锁

wait办法与sleep办法比照

相同点：
（1）wait和sleep都能够使线程休眠
（2）wait和sleep在执行的过程中都能够接管到终止线程执行的告诉

不同点：
（1）wait必须synchronized一起应用，而sleep不必
（2）wait会开释锁，sleep不会开释锁
（3）wait是Object的办法，而sleep是Thread的办法
（4）默认状况下，wait不传递参数或者参数为0的状况下，它会进入waiting状态，而sleep会进入timed_waiting状态
（5）应用wait能够被动唤醒线程，而应用sleep不能被动唤醒线程

面试题

1.问：sleep（0）和wait（0）有什么区别
答：（1）sleep（0）示意过0毫秒后继续执行，而wait（0）会始终期待
（2）sleep（0）示意从新触发一次CPU竞争

2.为什么wait会开释锁，而sleep不会开释锁
答：sleep必须要传递一个最大等待时间的，也就是说sleep是可控的（对于工夫层面来讲），而wait是能够不传递工夫，从设计层面来讲，如果让wait这个没有超时等待时间的机制下开释锁的话，那么线程可能会始终阻塞，而sleep不会存在这个问题

3.为什么wait是Object的办法，而sleep是Thread的办法
答：wait须要操作锁，而锁是对象级别（所有的锁都在对象头当中），它不是线程级别，一个线程能够有多把锁，为了灵便起见，所有把wait放在Object当中

4.解决wait/notify随机唤醒的问题
答：能够应用LockSupport中的park，unpark办法，留神：locksupport尽管不会报interrupted的异样，然而能够监听到线程终止的指令

最初

都看到这里了，记得点个赞哦！

关于后端:关于线程安全问题这一篇应该是全网讲的最明白的了

线程平安与不平安

线程不平安的因素：

volatile

解决线程不平安

synchronized

操作锁的流程

代码示例

留神

三种应用场景

Lock手动锁

偏心锁与非偏心锁

两种锁区别

死锁

死锁定义

死锁示例

死锁的4个必要条件

线程通信

wait办法

wait办法与sleep办法比照

面试题

最初

评论

发表回复取消回复

更多文章

DDN HPC 存储硬件架构设计深度分析

探秘IO500：从Lustre并行文件系统出发，开启HPC存储性能新征程

苹果iOS打包的ipa应用无法安装？一篇文章带你了解可能的原因及排查方法

图解Golang：从零开始实现简易版过期LRU缓存

关于后端:关于线程安全问题这一篇应该是全网讲的最明白的了

线程平安与不平安

线程不平安的因素：

volatile

解决线程不平安

synchronized

操作锁的流程

代码示例

留神

三种应用场景

Lock手动锁

偏心锁与非偏心锁

两种锁区别

死锁

死锁定义

死锁示例

死锁的4个必要条件

线程通信

wait办法

wait办法与sleep办法比照

面试题

最初

评论

发表回复 取消回复

更多文章

DDN HPC 存储硬件架构设计深度分析

探秘IO500：从Lustre并行文件系统出发，开启HPC存储性能新征程

苹果iOS打包的ipa应用无法安装？一篇文章带你了解可能的原因及排查方法

图解Golang：从零开始实现简易版过期LRU缓存

发表回复取消回复