变量的线程安全只会发生在实例变量,而方法内部的变量永远线程安全
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