-
什么是线程安全 简单说来,当多个线程访问某一个类(对象或方法)时,这个对象始终都能表现出正确的行为,那么这个类(对象或方法)就是线程安全的。
举例说明
public class MyThread extends Thread{
private int count = 5 ;
public static void main(String[] args) {
MyThread myThread = new MyThread();
Thread t1 = new Thread(myThread,"t1");
Thread t2 = new Thread(myThread,"t2");
Thread t3 = new Thread(myThread,"t3");
Thread t4 = new Thread(myThread,"t4");
Thread t5 = new Thread(myThread,"t5");
t1.start();
t2.start();
t3.start();
t4.start();
t5.start();
}
public void run(){
count--;
System.out.println(this.currentThread().getName() + " count = "+ count);
}
}
结果如下
t1 count = 3
t3 count = 2
t5 count = 1
t2 count = 4
t4 count = 0
这里的操作很显然是线程不安全的,当多个线程同时执行count–时,会有多个线程同时得到count变量并进行减操作,所以结果如上所示。
为了实现线程安全,我们引入synchronized对当前对象加锁实现线程安全。
public class MyThread extends Thread{
private int count = 5 ;
public static void main(String[] args) {
MyThread myThread = new MyThread();
Thread t1 = new Thread(myThread,"t1");
Thread t2 = new Thread(myThread,"t2");
Thread t3 = new Thread(myThread,"t3");
Thread t4 = new Thread(myThread,"t4");
Thread t5 = new Thread(myThread,"t5");
t1.start();
t2.start();
t3.start();
t4.start();
t5.start();
}
public synchronized void run(){
count--;
System.out.println(this.currentThread().getName() + " count = "+ count);
}
}
结果如下
t2 count = 4
t4 count = 3
t1 count = 2
t3 count = 1
t5 count = 0
显然这是我们想要的结果。这里对synchronized做一个简单的介绍
-
synchronized介绍
synchronized取得的锁都是对象锁,而不是把一段代码(方法)当做锁,
所以代码中哪个线程先执行synchronized关键字的方法,哪个线程就持有该方法所属对象的锁(Lock)
public class MultiThread {
private int num = 0;
public synchronized void printNum(String tag){
try {
if(tag.equals("a")){
num = 100;
System.out.println("a赋值num完成");
Thread.sleep(1000);
} else {
num = 200;
System.out.println("b赋值num完成");
}
System.out.println("num = " + num);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
//注意观察run方法输出顺序
public static void main(String[] args) {
//俩个不同的对象
final MultiThread m1 = new MultiThread();
final MultiThread m2 = new MultiThread();
Thread t1 = new Thread(new Runnable() {
@Override
public void run() {
m1.printNum("a");
}
});
Thread t2 = new Thread(new Runnable() {
@Override
public void run() {
m2.printNum("b");
}
});
t1.start();
t2.start();
}
}
由于synchronized只是对对象m1、m2加锁,所以输出结果如下(不是我们想要的)
b赋值num完成
a赋值num完成
num = 200
num = 100
而我们想要的结果为
a赋值num完成
num = 100
b赋值num完成
num = 200
为了达到这个结果,我们对代码进行改造
public class MultiThread {
private static int num = 0;
public synchronized static void printNum(String tag){
try {
if(tag.equals("a")){
num = 100;
System.out.println("a赋值num完成");
Thread.sleep(1000);
} else {
num = 200;
System.out.println("b赋值num完成");
}
System.out.println("num = " + num);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
//注意观察run方法输出顺序
public static void main(String[] args) {
//俩个不同的对象
final MultiThread m1 = new MultiThread();
final MultiThread m2 = new MultiThread();
Thread t1 = new Thread(new Runnable() {
@Override
public void run() {
m1.printNum("a");
}
});
Thread t2 = new Thread(new Runnable() {
@Override
public void run() {
m2.printNum("b");
}
});
t1.start();
t2.start();
}
}
输出的结果是我们想要的,这里在静态方法上加synchronized关键字,表示锁定.class类,类一级别的锁(独占.class类)。
synchronized对于代码块的加锁方式比较灵活,如下所示:
public void method1(){
synchronized (this) { //对象锁
try {
System.out.println("do method1..");
Thread.sleep(2000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
public void method2(){ //类锁
synchronized (ObjectLock.class) {
try {
System.out.println("do method2..");
Thread.sleep(2000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
private Object lock = new Object();
public void method3(){ //任何对象锁
synchronized (lock) {
try {
System.out.println("do method3..");
Thread.sleep(2000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}