多线程核心技术-并发访问对象&变量

变量的线程安全只会发生在实例变量，而方法内部的变量永远线程安全

synchronized关键字：可进行方法锁，块锁，它的特性如下

1.多个对象多个锁，创建多个对象实例，调用synchronized方法，不同步

2.加锁方法和不加锁方法不影响，但所有加锁的方法会同步串行执行：例如方法A加锁，B不加锁，C加锁，线程A访问方法A期间，线程B可以访问方法B，但线程C需要等待线程A执行完方法A才能访问方法C

3.锁重入：当一个线程获得锁以后，再次请求对象锁时可以继续获得对象所，用下面代码解释下

Service类

public class Service{
    synchronized public void service1(){
        System.out.println("service1");
        service2();
    }
    synchronized public void service2(){
        System.out.println("service2");
        service3();
    }
    synchronized public void service3(){
        System.out.println("service3");
    }
}

Thread类

public class MyThread extends Thread{
    @Override
    public void run(){
        Service service = new Service();
        service.service1();
    }
}

运行类

public class Run{
    public static void main(String[] args){
        MyThread myThread = new MyThread();
        myThread.start();
    }
}

控制台会输出三行，即service1 service2 service3

同样这种锁重入也会发生在父子继承中

4.出现异常，锁自动释放

5.同步不具有继承性，所以子类重写父类方法应手动加上synchronized

6.同步代码块：synchronized(this)的时候是锁对象，同样"this"可以是任意对象例如synchronized("AA")，括号内为锁的标识（对象监视器的标识），只有对象相同的时候，访问该代码块才会进行同步（只要对象相同，即便对象的属性改变了，也是同一把锁）

7.静态锁和非静态锁：解释起来比较麻烦，用代码描述

TestObject类

public class TestObject {
    synchronized public static void methodA(){
        System.out.println("start methodA");
        try {
            Thread.sleep(5000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("end methodA");
    }
    synchronized public static void methodB(){
        System.out.println("join in methodB");
    }
}

创建两个线程类ThreadA和ThreadB，一模一样，不用阅读

public class ThreadA extends Thread{
 
    private TestObject testObject;
 
    public ThreadA(TestObject testObject) {
        this.testObject = testObject;
    }
 
    @Override
    public void run() {
        super.run();
        testObject.methodA();
    }
}
  
public class ThreadB extends Thread {
 
    private TestObject testObject;
 
    public ThreadB(TestObject testObject) {
        this.testObject = testObject;
    }
 
    @Override
    public void run() {
        super.run();
        testObject.methodB();
    }
}

测试类Run

public class Run {
 
    public static void main(String[] args) {
        TestObject testObject = new TestObject();
//        TestObject testObject2 = new TestObject();
        ThreadA threadA = new ThreadA(testObject);
        ThreadB threadB = new ThreadB(testObject);
        threadA.start();
        threadB.start();
    }
}

运行结果为：

start methodA
end methodA
join in methodB

说明同样给静态方法加锁，效果和非静态方法锁一样，同步执行，线程安全，现在更改一下TestObject，去掉methodB的static，则运行结果为：

start methodA
join in methodB
end methodA

说明静态方法和非静态方法所持有的锁是不同的锁，非静态方法是运行时候的对象锁，而静态方法是编译期间就定好的类锁（class锁）所以不是同一个锁，那么问题来了，既然是静态锁，那么多个创建多个对象他们的静态锁是否是同一把锁（非静态方法是对象所，所以多个对象的锁是不同的），答案是肯定的，将TestObject的methodB方法的static加上，然后修改测试类为

public class Run {
 
    public static void main(String[] args) {
        TestObject testObject = new TestObject();
        TestObject testObject2 = new TestObject();
        ThreadA threadA = new ThreadA(testObject);
        ThreadB threadB = new ThreadB(testObject2);
        threadA.start();
        threadB.start();
    }
}

执行结果为：

start methodA
end methodA
join in methodB

可以看到不同对象的静态锁是同一把

8.死锁：两个方法互相持有对方的锁，永不释放互相等待就会造成死锁，避免死锁的方法有很多，不要同事对多个属性加锁，不要在锁方法中调用另一个锁方法等

死锁的排查，可以通过jdk提供的工具，进入jdk的bin目录，执行jps，找到线程id

执行jstack -l 8856查看具体信息

最后是volatile关键字，经常会用volatile和synchronized进行对比，其实只要知道两者的原理就很容易进行比较

从概念上volatile具有线程间可见性，而不具备原子性并且线程之间访问volatile修饰的关键字不会发生阻塞，而synchronized具有可见性和原子性，但是访问synchronized修饰的方法或代码块是同步的，对于synchronized的特性上面已经介绍，这里简单说一下volatile的功能

从网上找了张比较大众的JMM图

每一个线程都有自己的工作内存，多个线程共享一个主内存，而volatile的特性就是在读取变量的时候强制从主内存读取，这样保证每次拿到的都是最新的，但是不可进行复核操作，例如读取变量i，之后进行i++

如果进行i++可以考虑使用原子类，例如AtomicInteger