在Java中，提供了两种方式来实现同步互斥访问：synchronized和Lock。对临界资源加上互斥锁，当一个线程在访问该临界资源时，其他线程便只能等待。每一个对象都拥有一个锁标记（monitor），也称为监视器，多线程同时访问某个对象时，线程只有获取了该对象的锁才能访问。当某个线程调用该对象的synchronized方法或者访问synchronized代码块时，这个线程便获得了该对象的锁。
synchronized：
当一个线程访问object的一个synchronized(this)同步代码块时，另一个线程仍然可以访问该object中的非synchronized(this)同步代码块而synchronized(this)同步代码块的访问将被阻塞（这里是指所有的同步方法/代码块，而不仅仅是同一个方法/代码块）。也就是说，当一个线程访问object的一个synchronized(this)同步代码块时，它就获得了这个object的对象锁。结果，其它线程对该object对象所有同步代码部分的访问都被暂时阻塞。
被修饰的同步代码块，其作用的范围是调用这个代码块的对象，我们在用synchronized关键字的时候，尽量缩小代码段的范围，能在代码段上加同步就不要再整个方法上加同步。减小锁的粒度，使代码更大程度的并发。
- synchronized方法，被修饰的方法成为同步方法，其作用范围是整个方法，作用对象是调用这个方法的实例。
- synchronized静态方法，修饰一个static静态方法，其作用范围是整个静态方法，作用对象是这个类的所有实例。
- synchronized类锁，synchronized(className.class)，作用的对象是这个类的所有实例。
synchronized()方法中是锁住的对象，即synchronized(this)锁住的只是实例本身，同一个类的不同实例调用的synchronized方法并不会被锁住，而synchronized(className.class)实现了全局锁的功能，所有这个类的实例调用这个方法都受到锁的影响，此外()中还可以添加一个具体的实例，实现给具体实例加锁。
public class Thread1 implements Runnable {
public void run() {
synchronized(this) {
for (int i = 0; i < 5; i++) {
System.out.println(Thread.currentThread().getName() + " synchronized loop " + i);
}
}
}
public static void main(String[] args) {
Thread1 t1 = new Thread1();
Thread1 t1_2 = new Thread1();
Thread ta = new Thread(t1, "A");
Thread tb = new Thread(t1, "B"); //ta与tb互斥
Thread tc = new Thread(t1_2, "C");//tc与ta，tb不互斥
ta.start();
tb.start();
tc.start();
}
}
synchronized 静态：
如果一个线程执行一个实例的非静态的synchronized方法，另外一个线程需要执行这个实例静态的 synchronized方法，此时不会发生互斥现象，因为访问static synchronized方法占用的是类锁，而访问非static的synchronized方法占用的是实例锁，所以不存在互斥现象。
synchronized(A.class) {
... //锁住了类（包括静态成员）的同步代码块
}
如下Something类的两个实例x与y，那么下列组方法可以被1个以上线程同时访问呢?
pulbic class Something(){
public synchronized void isSyncA(){}
public synchronized void isSyncB(){}
public static synchronized void cSyncA(){}
public static synchronized void cSyncB(){}
}
a. x.isSyncA()与x.isSyncB()
b. x.isSyncA()与y.isSyncA()
c. x.cSyncA()与y.cSyncB()
a的话是同个实例中的，故不可以。
b中是不同实例的，所以可以同时访问。
c中是针对static synchronized，上文所说所有的static方法共用一个监视块，故不能够同时访问。
Lock：
与synchronized的不同：
- Lock支持在等待一定的时间或者能够响应中断。
- Lock支持在多个线程都只是进行读操作时，线程之间不会发生冲突，通过Lock就可以办到。
- 通过Lock可以知道线程有没有成功获取到锁。
- Lock不是Java语言内置的。synchronized是Java语言的关键字，因此是内置特性。Lock是一个类，通过这个类可以实现同步访问。
- Lock必须要用户去手动释放锁，而synchronized方法或者synchronized代码块执行完之后，系统会自动让线程释放对锁的占用。
ReentrantLock是实现了Lock接口的类，用lock改写上面的synchronized方法：
public class MyThread implements Runnable {
private Lock lock = new ReentrantLock();
public void run() {
//Lock lock = new ReentrantLock(); //注意变量lock的范围
lock.lock();
try {
for (int i = 0; i < 5; i++) {
System.out.println(Thread.currentThread().getName() + " synchronized loop " + i);
}
} catch (Exception e) {
// TODO: handle exception
}finally {
System.out.println(thread.getName()+"释放了锁");
lock.unlock();
}
}
public static void main(String[] args) {
MyThread t1 = new MyThread();
MyThread t2 = new MyThread();
Thread ta = new Thread(t1, "A");
Thread tb = new Thread(t1, "B"); //ta与tb互斥
Thread tc = new Thread(t2, "C");//tc与ta，tb不互斥
ta.start();
tb.start();
tc.start();
}
}
注意如果lock变量是局部变量，每个线程执行该方法时都会保存一个副本，那么理所当然每个线程执行到lock.lock()处获取的是不同的锁，所以就不会发生冲突，也就没有起到lock的效果。
tryLock()：
tryLock()表示用来尝试获取锁，如果获取成功，则返回true，如果获取失败（即锁已被其他线程获取），则返回false，也就说这个方法无论如何都会立即返回。在拿不到锁时不会一直在那等待。
tryLock(long time, TimeUnit unit)方法和tryLock()方法是类似的，区别在于这个方法在拿不到锁时会等待一定的时间，在时间期限之内如果还拿不到锁，就返回false。如果在等待期间内拿到了锁，则返回true。
private Lock lock = new ReentrantLock();
public void mySyncMethod() {
if(lock.tryLock()) {
try{
//处理任务
}catch(Exception ex){
}finally{
lock.unlock(); //释放锁
}
}else {
//如果不能获取锁，则直接做其他事情
}
}
读写锁：
private ReentrantReadWriteLock rwlock = new ReentrantReadWriteLock();
public void mySyncMethod() {
rwl.readLock().lock();
try{
//处理任务
}catch(Exception ex){
}finally{
lock.unlock(); //释放锁
}
}
这样就提升了读操作的效率。不过要注意的是，如果有一个线程已经占用了读锁，则此时其他线程如果要申请写锁，则申请写锁的线程会一直等待释放读锁。
如果有一个线程已经占用了写锁，则此时其他线程如果申请写锁或者读锁，则申请的线程会一直等待释放写锁。
Volatile：
volitile的使用场景，通过关键字sychronize可以防止多个线程进入同一段代码，在某些特定场景中，volitile相当于一个轻量级的sychronize，因为不会引起线程的上下文切换，一旦一个共享变量（类的成员变量、类的静态成员变量）被volatile修饰之后，那么就具备了两层语义：
- 保证了不同线程对这个变量进行操作时的可见性，即一个线程修改了某个变量的值，这新值对其他线程来说是立即可见的。volatile关键字会强制将修改的值立即写入主存，使线程的工作内存中缓存变量行无效。
- 禁止进行指令重排序。
在java虚拟机的内存模型中，有主内存和工作内存的概念，每个线程对应一个工作内存，并共享主内存的数据。
- 对于普通变量：读操作会优先读取工作内存的数据，如果工作内存中不存在，则从主内存中拷贝一份数据到工作内存中；写操作只会修改工作内存的副本数据，这种情况下，其它线程就无法读取变量的最新值。
-
对于volatile变量，读操作时JMM会把工作内存中对应的值设为无效，要求线程从主内存中读取数据；写操作时JMM会把工作内存中对应的数据刷新到主内存中，这种情况下，其它线程就可以读取变量的最新值。
但是volatile关键字最致命的缺点是不支持原子性。synchronized关键字是防止多个线程同时执行一段代码，那么就会很影响程序执行效率，而volatile关键字在某些情况下性能要优于synchronized，但volatile关键字是无法替代synchronized关键字的，因为volatile关键字无法保证操作的原子性。通常来说，使用volatile必须具备以下2个条件：
- 对变量的写操作不依赖于当前值。
- 该变量没有包含在具有其他变量的不变式中。
参考：
