在多线程环境中并发访问资源时会产生不可预料的结果，防止这种冲突的产生是当资源被一个任务使用时，在其上加锁。第一个访问某个资源的任必须锁定这个资源，使其它任务在资源未被解锁之前无法访问它。而其在被解锁之时另一个任务就可以锁定并使用它，每个任务锁定的资源都是最新的结果。
Java提供Synchronized关键字，为防止资源冲突提供了内置支持
锁机制有如下两种特性
- 互斥性，同一时间只允许一个线程访问共享资源
- 可见性，锁在被释放之前对共享变量的修改，对随后获得该锁的另一个线程是可见的
可以根据锁的作用范围通俗的把锁分为类锁和对象锁
类锁：
它表示的是给Class类上锁，类锁对类的所有对象实例都起作用，Class类是一个特殊的类，它包含了与类有关的信息，使用如下方式加锁时就是类锁，它表示这个类同一时间只能被一个线程使用。
Synchronized(类.class){}- 静态方法和静态对象
对象锁：
所有的对象都含有单一的锁（也称为监视器锁），当在对象上调用其任意synchronized方法时，此对象都被加锁。它表示一个对象实例在同一时间只能被一个线程使用。
Synchronized(this|object){}- 修饰非静态方法
对象锁的验证
下图两个线程共用一个Runnable对象，test1和test2是两个普通的方法
public class TestMain {
public static void main(String arg[]) {
SyncThread target = new SyncThread();
Thread thread1 = new Thread(target, "SyncThread1");
Thread thread2 = new Thread(target, "SyncThread2");
thread1.start();
thread2.start();
}
}
public class SyncThread implements Runnable {
private static int count;
private final byte[] lock = new byte[0];
public SyncThread() {
count = 0;
}
@Override
public void run() {
if (Thread.currentThread().getName().contains("1")) {
test1();
} else if (Thread.currentThread().getName().contains("2")) {
test2();
}
}
private void test1() {
for (int i = 0; i < 5; i++) {
try {
System.out.println(Thread.currentThread().getName() + ": " + (count++));
Thread.sleep(500);
} catch (Exception e) {
e.printStackTrace();
}
}
}
private void test2() {
for (int i = 0; i < 5; i++) {
try {
System.out.println(Thread.currentThread().getName() + ": " + (count++));
Thread.sleep(500);
} catch (Exception e) {
e.printStackTrace();
}
}
}
}
从打印结果可以看出test1和test2方法执行是不同步的。
SyncThread2: 0
SyncThread1: 0
SyncThread1: 1
SyncThread2: 2
SyncThread1: 3
SyncThread2: 4
SyncThread2: 5
SyncThread1: 5
SyncThread1: 6
SyncThread2: 6
当把test1和test2写成普通的同步方法时，我们再来看看打印的结果
private synchronzied void test1() {
...
}
private synchronzied void test2() {
...
}
SyncThread1: 0
SyncThread1: 1
SyncThread1: 2
SyncThread1: 3
SyncThread1: 4
SyncThread2: 5
SyncThread2: 6
SyncThread2: 7
SyncThread2: 8
SyncThread2: 9
可以看出两个线程是按顺序执行的，thread1执行完了才轮到thread2执行。当test1还没执行完时，target对象被锁住，test2处于等待的状态，直到test1释放锁的时候test2才能执行。所以对于某个特定的对象而言，其所有Synchronized方法共享同一个锁。
当test1和test2改成是同步控制块时，打印结果和上面是一样的，这种情况锁住的也是对象本身。使用同步控制块而不是同步方法，可以使多个任务访问对象的时间性能得到提高，平时使用时建议尽量使用同步控制块。
private void test1() {
synchronzied(this|lock){
...
}
}
private void test2() {
synchronzied(this|lock){
...
}
}
synchronized锁重入
上面的测试中还应用到了synchronized锁重入的功能，它表示的是当一个线程得到一个对象锁后，再次请求次对象锁时是可以再次得到该对象当锁的。如果没有锁重入的话，就会造成死锁。
当一个对象上的不同方法锁住的是不同的对象时，各自的锁互相独立，下面把test1在this对象上同步，test在lock对象上同步。
private void test1() {
synchronzied(this){
...
}
}
private void test2() {
synchronzied(lock){
...
}
}
从打印结果可以看出，test1和test2的执行变成不同步了。因此在使用synchronized时要注意同步的对象。
SyncThread1: 0
SyncThread2: 1
SyncThread1: 2
SyncThread2: 3
SyncThread1: 4
SyncThread2: 5
SyncThread1: 6
SyncThread2: 6
SyncThread1: 7
SyncThread2: 8
类锁的验证
需要注意的是，以上同步的条件是test1和test2处于同一个对象，当它们不是处于同一个对象时是不同步的
public static void main(String arg[]) {
SyncThread target = new SyncThread();
Thread thread1 = new Thread(new SyncThread(), "SyncThread1");
Thread thread2 = new Thread(new SyncThread(), "SyncThread2");
thread1.start();
thread2.start();
}
把测试方法改成thread1和thread2不共用一个Runnable，打印结果如下
SyncThread1: 0
SyncThread2: 1
SyncThread1: 2
SyncThread2: 2
SyncThread1: 3
SyncThread2: 3
SyncThread1: 4
SyncThread2: 4
SyncThread1: 5
SyncThread2: 5
要想在不同对象也能同步，要实现的是类锁。针对每个类，也有一个锁（作为类的Class对象的一部分）
在main方法里还是继续用不同的Runnable对象
Thread thread1 = new Thread(new SyncThread(), "SyncThread1");
Thread thread2 = new Thread(new SyncThread(), "SyncThread2");
把test1和test2改成如下静态的同步方法
private static synchronized void test1() {
...
}
private static synchronized void test2() {
...
}
打印结果如下，这个就印证了static synchronized方法的锁是类锁，所以static synchronized可以防止在类的范围内防止并发数据对static数据的并发访问
SyncThread1: 0
SyncThread1: 1
SyncThread1: 2
SyncThread1: 3
SyncThread1: 4
SyncThread2: 5
SyncThread2: 6
SyncThread2: 7
SyncThread2: 8
SyncThread2: 9
test1和test2写成如下形式时和静态同步方法的结果和上面的static方法是一样的，这种用法锁住的是Class类
private void test1() {
synchronzied(SyncThread.class|静态对象){
...
}
}
private void test1() {
synchronzied(SyncThread.class|静态对象){
...
}
}
最后说一下什么时候应该使用同步机制，如果你正在写一个变量，它可能接下来被另一个线程读取，或者正在读取一个上一次已经被另一个线程写过的变量，那么你必须使用同步方法。