什么是线程安全
当多个线程去访问同一个类(对象或方法)的时候,该类都能表现出正常的行为(与自己预想的结果一致),那我们就可以说这个类是线程安全的。
public class Demo1 {
static int num = 0;
public static void m1() {
for (int i = 0; i < 10000; i++) {
num++;
}
}
public static class T1 extends Thread {
@Override
public void run() {
Demo1.m1();
}
}
public static void main(String[] args) throws InterruptedException {
T1 t1 = new T1();
T1 t2 = new T1();
T1 t3 = new T1();
t1.start();
t2.start();
t3.start();
//等待3个线程结束打印num
t1.join();
t2.join();
t3.join();
System.out.println(Demo1.num);
/**
* 打印结果:
* 25572
*/
}
}
Demo1 中有个静态变量 num,默认值是 0,m1()方法中对 num++执行 10000 次,main 方法中创建了 3 个线程用来调用 m1()方法,然后调用 3 个线程的 join()方法,用来等待 3 个线程执行完毕之后,打印 num 的值。我们期望的结果是 30000,运行一下,但真实的结果却不是 30000。上面的程序在多线程中表现出来的结果和预想的结果不一致,说明上面的程序不是线程安全的。
线程安全是并发编程中的重要关注点,应该注意到的是,造成线程安全问题的主要诱因有两点:
一是存在共享数据(也称临界资源)
二是存在多条线程共同操作共享数据
因此为了解决这个问题,我们可能需要这样一个方案,当存在多个线程操作共享数据时,需要保证同一时刻有且只有一个线程在操作共享数据,其他线程必须等到该线程处理完数据后再进行,这种方式有个高尚的名称叫互斥锁
即能达到互斥访问目的的锁,也就是说当一个共享数据被当前正在访问的线程加上互斥锁后,在同一个时刻,其他线程只能处于等待的状态,直到当前线程处理完毕释放该锁。在 Java 中,关键字 synchronized 可以保证在同一个时刻,只有一个线程可以执行某个方法或者某个代码块(主要是对方法或者代码块中存在共享数据的操作),同时我们还应该注意到 synchronized 另外一个重要的作用,synchronized 可保证一个线程的变化(主要是共享数据的变化)被其他线程所看到(保证可见性,完全可以替代 volatile 功能),这点确实也是很重要的。
synchronized三种使用方式
1.作用于实例
****所谓实例对象锁就是用 synchronized 修饰实例对象的实例方法,注意是实例方法,不是静态方法:
1.实例方法上加 synchronized,线程安全的前提是,多个线程操作的是同一个实例,如果多个线程作用于不同的实例,那么线程安全是无法保证的
2.同一个实例的多个实例方法上有 synchronized,这些方法都是互斥的,同一时间只允许一个线程操作同一个实例的其中的一个 synchronized 方法
2.作用于静态方法
当 synchronized 作用于静态方法时,锁的对象就是当前类的 Class 对象。
3.作用于静态代码块
某些情况下,我们编写的方法体可能比较大,同时存在一些比较耗时的操作,而需要同步的代码又只有一小部分,如果直接对整个方法进行同步操作,可能会得不偿失,此时我们可以使用同步代码块的方式对需要同步的代码进行包裹,这样就无需对整个方法进行同步操作了,同步代码块的使用示例如下:
public class Demo5 implements Runnable {
static Demo5 instance = new Demo5();
static int i = 0;
@Override
public void run() {
//省略其他耗时操作....
//使用同步代码块对变量i进行同步操作,锁对象为instance
synchronized (instance) {
for (int j = 0; j < 10000; j++) {
i++;
}
}
}
public static void main(String[] args) throws InterruptedException {
Thread t1 = new Thread(instance);
Thread t2 = new Thread(instance);
t1.start();
t2.start();
t1.join();
t2.join();
System.out.println(i);
}
}
将 synchronized 作用于一个给定的实例对象 instance,即当前实例对象就是锁对象,每次当线程进入 synchronized 包裹的代码块时就会要求当前线程持有 instance 实例对象锁,如果当前有其他线程正持有该对象锁,那么新到的线程就必须等待,这样也就保证了每次只有一个线程执行 i++;操作。当然除了 instance 作为对象外,我们还可以使用 this 对象(代表当前实例)或者当前类的 class 对象作为锁,如下代码:
//this,当前实例对象锁
synchronized(this){
for(int j=0;j<1000000;j++){
i++;
}
}
//class对象锁
synchronized(Demo5.class){
for(int j=0;j<1000000;j++){
i++;
}
}
分析代码是否互斥的方法,先找出 synchronized 作用的对象是谁,如果多个线程操作的方法中 synchronized 作用的锁对象一样,那么这些线程同时异步执行这些方法就是互斥的。