一.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();
}
}
}