java 多线程同步
一.synchronized关键字
同步方法
每个对象都包含一把锁(也叫做监视器),它自动称为对象的一部分(不必为此写任何特殊的代码)。调用任何synchronized方法时,对象就会被锁定,不可再调用那个对象的其他任何synchronized方法,除非第一个方法完成了自己的工作。
示例代码如下:
public class SimpleThread implements Runnable { private int count = 0; @Override public void run() { while (true) { try { test(); } catch (InterruptedException e) { e.printStackTrace(); } } } private synchronized void test() throws InterruptedException { System.out.println(Thread.currentThread().getName() + ":" + count++); Thread.sleep(100); } public static void main(String[] args) { SimpleThread sd = new SimpleThread(); for (int i = 0; i < 3; i++) { new Thread(sd).start(); } } }
同步块
在进入同步块之前,必须在synchObject上取得锁。如果已有其他线程取得了这把锁,块便不能进入,必须等候那把锁被释放。一般情况下,当前对象作为锁来使用。
示例代码如下:
public class SimpleThread implements Runnable { private int count = 0; @Override public void run() { while (true) { try { test(); } catch (InterruptedException e) { e.printStackTrace(); } } } private void test() throws InterruptedException { synchronized (this) { System.out.println(Thread.currentThread().getName() + ":" + count++); } Thread.sleep(100); } public static void main(String[] args) { SimpleThread sd = new SimpleThread(); for (int i = 0; i < 3; i++) { new Thread(sd).start(); } } }
注:同步是一种高开销的操作,因此应该尽量减少同步的内容。 通常没有必要同步整个方法,使用synchronized代码块同步关键代码即可。
二.使用特殊域变量(volatile)
volatile关键字为域变量的访问提供了一种免锁机制,使用volatile修饰域相当于告诉虚拟机该域可能会被其他线程更新, 因此每次使用该域就要重新计算,而不是使用寄存器中的值,volatile不会提供任何原子操作,它也不能用来修饰final类型的变量。
public class SimpleThread implements Runnable { private volatile int count = 0; @Override public void run() { while (true) { try { test(); } catch (InterruptedException e) { e.printStackTrace(); } } } private void test() throws InterruptedException { System.out.println(Thread.currentThread().getName() + ":" + count++); Thread.sleep(100); } public static void main(String[] args) { SimpleThread sd = new SimpleThread(); for (int i = 0; i < 3; i++) { new Thread(sd).start(); } } }
注:由于线程执行速度不一样,所以控制台打印的结果不全是按从大到小来的。
三.使用java.util.concurrent包
在JavaSE5.0中新增了一个java.util.concurrent包来支持同步。ReentrantLock类是可重入、互斥、实现了Lock接口的锁,它与使用synchronized方法和快具有相同的基本行为和语义,并且扩展了其能力。
示例代码如下:
import java.util.concurrent.locks.Lock; import java.util.concurrent.locks.ReentrantLock; public class SimpleThread implements Runnable { private int count = 0; private Lock lock = new ReentrantLock(); @Override public void run() { while (true) { try { test(); } catch (InterruptedException e) { e.printStackTrace(); } } } private void test() throws InterruptedException { lock.lock(); try { System.out.println(Thread.currentThread().getName() + ":" + count++); } finally { lock.unlock(); } Thread.sleep(100); } public static void main(String[] args) { SimpleThread sd = new SimpleThread(); for (int i = 0; i < 3; i++) { new Thread(sd).start(); } } }
四.使用ThreadLocal管理变量
如果使用ThreadLocal管理变量,则每一个使用该变量的线程都获得该变量的副本,副本之间相互独立,这样每一个线程都可以随意修改自己的变量副本,而不会对其他线程产生影响。
示例代码如下:
public class SimpleThread implements Runnable { private ThreadLocal<Integer> count = new ThreadLocal<Integer>() { @Override protected Integer initialValue() { return 0; } }; @Override public void run() { while (true) { try { test(); } catch (InterruptedException e) { e.printStackTrace(); } } } private void test() throws InterruptedException { System.out.println(Thread.currentThread().getName() + ":" + count.get().toString()); count.set(count.get() + 1); Thread.sleep(100); } public static void main(String[] args) { SimpleThread sd = new SimpleThread(); for (int i = 0; i < 3; i++) { new Thread(sd).start(); } } }