一,关键字Synchronized
我们为什么要线程同步呢? 因为当我们有多个线程要同时访问一个变量或对象时,如果这些线程中既有读又有写操作时,就会导致变量值或对象的状态出现混乱,跟我们预期有出入,比如下面的例子
类Task有一个静态的变量num,有一个add()方法
package com.remote3c.main;
public class Task {
private static int num=0;
public void add(String name){
num++;
System.out.println(name +",你是第"+num+"个使用Task的线程");
}
}
一个线程类
package com.remote3c.main;
import java.util.concurrent.TimeUnit;
public class MyThread implements Runnable {
public Task task;
public MyThread(Task task) {
super();
this.task = task;
}
@Override
public void run() {
task.add(Thread.currentThread().getName());
try {
TimeUnit.MILLISECONDS.sleep(10);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
Test类
package com.remote3c.main;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
public class Test {
/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
ExecutorService exec =Executors.newCachedThreadPool();
Task task = new Task();
for(int i = 0;i<6;i++){
exec.execute(new MyThread(task));
}
exec.shutdown();
}
}
new 出5个线程,同时访问同一个对象task的add()方法,我们想要的结果是1,2,3这样按顺序递增的情况,可事实却是这样的
pool-1-thread-2,你是第1个使用Task的线程
pool-1-thread-1,你是第2个使用Task的线程
pool-1-thread-6,你是第4个使用Task的线程
pool-1-thread-4,你是第3个使用Task的线程
pool-1-thread-3,你是第5个使用Task的线程
pool-1-thread-5,你是第6个使用Task的线程
这种混乱的结果跟我们想要的结果相去甚远,究其原因是因为多个线程同时访问共享资源(num),没有先后顺序才导致的混乱局面,怎么才能保证多个线程同时访问一个资源(共享资源)时,有序的,正确的进行呢,那就是在一个线程访问共享资源时其他的都得等它结束才能访问,就是给共享资源加锁,java中用关键字synchronized来实现同步
只需要在add()方法上加上这个关键字,如下
package com.remote3c.main;
public class Task {
private static int num=0;
public synchronized void add(String name){
num++;
System.out.println(name +",你是第"+num+"个使用Task的线程");
}
}
输出结果 就会是我们想要的那种
pool-1-thread-1,你是第1个使用Task的线程
pool-1-thread-2,你是第2个使用Task的线程
pool-1-thread-4,你是第3个使用Task的线程
pool-1-thread-6,你是第4个使用Task的线程
pool-1-thread-5,你是第5个使用Task的线程
pool-1-thread-3,你是第6个使用Task的线程
二,原子性和可视性
1 原子性
原子是发生化学反应的最小单位,顾名思义即为不可再拆分。 原子操作是不能被线程中断机制中断的操作 ,一旦操作开始,则它一定在可能的切换到其他线程之前执行完毕。简而言之就是不能被中断的操作,如 赋值或 return。2 可视性
(1)在多核处理器中,如果多个线程同时对一个变量进行操作,这些线程可能被分配到不同的CPU中运行。由于编译器会对代码进行优化,当某个线程要对这个变量进行操作时,为了提高操作速度,这个线程所在的CPU会从主存中复制这个变量到自己的缓存中,等操作完成后再存储到主存中。因此不同的线程对应的这个变量就有不同的状态。(注:在单核处理器中也存在可视性问题)
(2) 变量的可视性:假设有两个线程T1和T2分别被安排到了两个不同的CPU中(cpu1、cpu2),则T1和T2对变量a的修改互不可视,如T1对a进行修改之后,只是对cpu1缓存中的a运行修改,没有立即被写入到主存中,因此当线程T2再对a进行操作时,操作的并不是被线程T1修改后的新值。此时线程T1和线程T2对于变量a是互不可视的。
(3)不可视性产生的问题:多个线程对某个变量的操作互不可视,可能造成某些操作被覆盖,产生错误的结果。如对于变量a,线程T1和线程T2都对其进行a++操作,T1操作a++后并没有及时地将结果写入到主存中去,而是继续执行其它对a的操作,当T2再执行a++操作后,它并没有发现a的值已被线程T1修改,这样就由于a的值没有被及时更新而产生错误。三、死锁
死锁不是我们想见的,可是有时候它偏偏又会出现,所以为了防止它,我们有必要了解它,从而远离它,产生死锁的原因有很多,最常见的是同时锁住两个对象,而另外一个锁也同时锁住了这两个对象,又互有先后,就会出现死锁,经典的死锁是哲学家吃饭的问题,下面我们来看一个死锁
package com.remote3c.main;
import java.util.concurrent.TimeUnit;
public class DeadLock implements Runnable {
public int flag ;
static Object ob1 =new Object() ,ob2 =new Object();
public void run() {
if(flag==1){
System.out.println("flag = "+flag);
synchronized (ob1) {
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
synchronized (ob2) {
System.out.println("你是第一个线程flag =1");
}
}
}
if(flag==2){
System.out.println("flag = "+flag);
synchronized (ob2) {
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
synchronized (ob1) {
System.out.println("你是第二个线程flag =2");
}
}
}
}
}
package com.remote3c.main;
public class Main {
public static void main(String[] args){
DeadLock d1=new DeadLock();
DeadLock d2=new DeadLock();
d1.flag=1;
d2.flag=2;
new Thread(d1).start();
new Thread(d2).start();
}
}
从本例中可以看出 两个线程d1和d2,有flag区分开来执行不同的方法块,flag=1时 锁住ob1,并且sleep()一秒钟,等待锁住ob2就能输出“你是第一个线程flag =1”,
而此时另外一个线程d2,执行flag=2的代码,锁住了ob2,再等待锁住ob1就能输出“你是第二个线程flag=2”了,可是很不幸,此时线程一锁住了ob1,在等ob2,而线程二锁住了ob2在等ob1,就这样一直等下去了,这种想象就叫做死锁。