多线程与高并发基础总结-线程的状态与关键字synchronized volatile_线程并发关键字synchronized,volite,wait,notiify,noyifyall,-CSDN博客

本文链接：https://blog.csdn.net/fqzj__/article/details/124348819

线程的状态一共是6个

new

尚未启动

runable

运行状态 runnable 正在运行的时候被wait join locksupport.park方法进行等待后编程waiting 状态在被notify 或者notifyall 或者locksupport.unpack 唤醒编程runable

blocked

堵塞等待锁为堵塞当获得锁后从此状态脱离

Teminated

88状态

Time_waiting

被sleep。或者wait加上时间后进入此状态时间结束则进入runable 状态

waiting

等待状态

关键字 synchronized volatile

synchronized

在多线程同一资源进行访问的时候进行上锁操作
原子性和可见性
上代码

public class SyTest implements Runnable {

    int count = 0;

    @Override
    public void run() {
        count++;
        System.out.println(Thread.currentThread().getName() + "    count==" + count);
    }

    public static void main(String[] args) {
        // 关键字  synchronized 的验证  可见性和原子性
        // 比如数 在多个线程里进行增加  A线程可以对数进行更改  B 也可以 那么 A B 都不知道其改动的结果 会出现问题
        SyTest syTest = new SyTest();
        for (int i = 0; i < 100; i++) {
            //创建线程 对其进行自增操作 增加100次
            new Thread(syTest, "name" + i).start();

        }

    }
}

结果会出现如图的错误
在这里插入图片描述

50 多加了2次并且直接46 到50

那么可以给run 方法添加关键字synchronized 把方法锁上。另外一个线程进入前要去看看锁的状态如果是同一个线程那么其锁的重入属性，是可以直接进入。如果资源已经被其他线程使用中则开始进行自旋，等待，或者进行锁升级或者自旋期间锁释放后使用资源
synchronized 现在是锁升级。一开始偏向锁比如有个空间 C 就是锁的记录空间我一个线程D进来了，会先去C中看看，无值，代表这个线程D是第一个使用的，记录下来。有值，判断是不是值一致，一致放行，不一致，查看锁的状态。如果已经释放了，那么进入，记录，如果没有释放，还有资源占用，线程D进行自旋，自旋等待锁释放，如果10次后锁还是被占用升级为重量级的os。

更改后的代码

public class SyTest implements Runnable {

    int count = 0;

    @Override
    public synchronized  void run() {
        count++;
        System.out.println(Thread.currentThread().getName() + "    count==" + count);
    }

    public static void main(String[] args) {
        // 关键字  synchronized 的验证  可见性和原子性
        // 比如数 在多个线程里进行增加  A线程可以对数进行更改  B 也可以 那么 A B 都不知道其改动的结果 会出现问题
        SyTest syTest = new SyTest();
        for (int i = 0; i < 100; i++) {
            //创建线程 对其进行自增操作 增加100次
            new Thread(syTest, "name" + i).start();

        }

    }
}

volatile

保证线程的可见性
比如有个线程A 和其他线程对一个资源都要进行更改，那么volatile
使用的是缓存一致性协议当A 做了更改资源不仅回写而且告诉其他使用的资源无效了资源进行了更改的时候发现无效则去重新获取
禁止指令重排序
指令重排序在运行的时候编译器或者处理器会对代码进行重新的排序
为了更好的优化或者提高cpu的使用率

上代码

public class Testvloatile {
    //e
    final static private Testvloatile testvloatile = new Testvloatile();

    public static Testvloatile getTestvloatile() {
        return testvloatile;
    }
}

class Testvloatile02 {
    //b
    static private Testvloatile testvloatile02 = null;

    public static synchronized Testvloatile getTestvloatile02() {
        if (testvloatile02 == null) {
            testvloatile02 = new Testvloatile();
        }
        return testvloatile02;
    }
}

class Testvloatile03 {
    //b
    static private volatile Testvloatile testvloatile03 = null;

    public static Testvloatile getTestvloatile03() {
        if (testvloatile03 == null) {
            synchronized (Testvloatile03.class) {
                if (testvloatile03 == null) {
                    testvloatile03 = new Testvloatile();
                }
            }
        }
        return testvloatile03;
    }
}