一、synchronized

1、静态方法的同步，是以当前类为锁对象

public class Test {public static void main(String[] args) {//线程1new Thread(){@Overridepublic void run() {Test.print("线程1");}}.start();//线程2new Thread(){@Overridepublic void run() {try {//线程2挂起，保证线程1先得到锁Thread.sleep(1000);} catch (Exception e) {}Test.print2("线程2");}}.start();}public static synchronized void print(String str){try {//挂起，不释放锁，线程2无法执行Thread.sleep(5000);} catch (Exception e) {}System.out.println(str);}public static synchronized void print2(String str){System.out.println(str);}}

因为两个方法的锁对象都是当前类，因此结果必然是：

线程1
线程2

2、非静态方法的同步，是以当前调用该方法的实例为锁对象

3、代码块的同步，是以输入的实例为锁对象,可以自定义锁对象，也可以直接使用当前调用方法的对象this

二、java.util.concurrent.locks.Lock

被Lock对象包含的代码片段都会被同步，同一个Lock对象的代码，即使在同一个类里的不同方法，或者不同类的方法里面都会被同步

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;public class Test {private static Lock lock = new ReentrantLock();public static void main(String[] args) {//线程1new Thread(){@Overridepublic void run() {Test.print("线程1");}}.start();//线程2new Thread(){@Overridepublic void run() {try {//挂起线程2，让线程1先抢到锁Thread.sleep(1000);} catch (Exception e) {}new Test().print2("线程2");}}.start();}public static  void print(String str){lock.lock();try {//挂起，不释放锁，线程2无法执行Thread.sleep(5000);} catch (Exception e) {}System.out.println(str);lock.unlock();}public void print2(String str){lock.lock();System.out.println(str);lock.unlock();}}

执行结果必然是：

线程1
线程2

三、java.util.concurrent.atomic

软件包 java.util.concurrent.atomic 是类的小工具包，支持在单个变量上解除锁定的线程安全编程。

import java.util.concurrent.atomic.AtomicInteger;public class Test {private static AtomicInteger ai = new AtomicInteger(0);private static int i = 0;public static void main(String[] args) {for (int j = 0; j < 10; j++) {for (int i = 0; i < 1000; i++) {new Thread(){@Overridepublic void run() {try {Thread.sleep(1000);} catch (Exception e) {}ai.incrementAndGet();}}.start();}for (int i = 0; i < 1000; i++) {new Thread(){@Overridepublic void run() {try {Thread.sleep(1000);} catch (Exception e) {}Test.i++;}}.start();}try {Thread.sleep(10000);System.out.println("ai = "+Test.ai);System.out.println("i = "+Test.i);} catch (Exception e) {}}}}

结果为：

ai = 1000
i = 992
ai = 2000
i = 1979
ai = 3000
i = 2979
ai = 4000
i = 3978
ai = 5000
i = 4977
ai = 6000
i = 5977
ai = 7000
i = 6977
ai = 8000
i = 7976
ai = 9000
i = 8976
ai = 10000
i = 9976

因为AtomicInteger.incrementAndGet()使用JNI调用了底层接口实现了同步。当然，并不是所有的 AtomicInteger方法都可以实现同步。