java多线程（juc讲解一）

java并发知识体系

java并发知识的体系如下：

并发锁说明

多线程编程中，会出现临界资源的被多个线程同时访问的情况，由于线程执行的过程是不可控的，所以需要采用同步机制来进行临界资源的访问。由此引出来锁机制，加锁的目的是，串行化访问临界资源，任一时刻只有一个线程可以获取资源。java中的锁如下分类

java线程生命状态

synchronized使用和原理

同步static类方法，锁的是当前实例对象
同步类方法，锁的是当前对象
同步代码块，锁的是括号里面的对象

private  static  int count = 0;
    public static void main(String[] args) {
        for (int i = 0; i <10 ; i++) {
            Thread thread = new Thread(new Runnable() {
                @Override
                public void run() {
                  TestAQS testAQS = new TestAQS();
                  testAQS.test1();
                }
            });
            thread.start();
        }
    }

    public static synchronized void test(){
        count++;
        System.out.println("count的值是:"+count);
    }

    public  synchronized void test1(){
        count++;
        System.out.println("count的值是:"+count);
    }

我们可以看到当前类加synchronized 如果不是单例的那么会导致失效，所以此时要用到单例模式，保证对象只有一个

private  static  int count = 0;
    public static void main(String[] args) {
        for (int i = 0; i <10 ; i++) {
            Thread thread = new Thread(new Runnable() {
                @Override
                public void run() {
                  TestAQS testAQS = getInstance();
                  testAQS.test1();
                }
            });
            thread.start();
        }
    }

    public static synchronized void test(){
        count++;
        System.out.println("count的值是:"+count);
    }

    public  synchronized void test1(){
        count++;
        System.out.println("count的值是:"+count);
    }

    private static volatile TestAQS instance = null;
    private TestAQS() {}
    public static TestAQS getInstance() {
        if (instance == null) {
            synchronized (TestAQS.class) {
                if (instance == null) {
                    instance = new TestAQS();
                }
            }
        }
        return instance;
    }

底层原理：
JVM内置锁通过synchronized 使用，通过内部对象Monitor(监视器锁)实现，基于进入和退出Monitor对象实现方法与代码块同步，监视器锁的实体依赖底层操作系统Mutex Lock（互斥锁）实现。

volatile说明

volatile保证了变量的可见性，不能保证变量的原子性。
volatile关键字可以禁止指令重排，保证代码前后执行顺序。