您的位置:首页 > 编程语言 > Java开发

java 多线程系列之线程安全和synchronized

2016-11-04 15:12 766 查看
什么是线程安全
简单说来,当多个线程访问某一个类(对象或方法)时,这个对象始终都能表现出正确的行为,那么这个类(对象或方法)就是线程安全的。

举例说明

public class MyThread extends Thread{
private int count = 5 ;
public static void main(String[] args) {
MyThread myThread = new MyThread();

4000
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();
}
}
}
内容来自用户分享和网络整理,不保证内容的准确性,如有侵权内容,可联系管理员处理 点击这里给我发消息