一、使用synchronized 关键字
1、同步代码块
//aVar 变量作为同步监视器，任何线程执行此代码块时必须获得对aVar 的锁定，即同时只有一个线程执行此代码块 //此方法逻辑：加锁——修改——释放锁 synchronized(aVar){ //业务 }
2、同步方法
此时以当前对象作为同步机监视器。
public synchronized void myMethod(){ //业务 }
释放同步监视器的锁定（重点）：
1、以下情况不会释放同步监视器
（1）、程序执行同步方法或同步代码块时，调用了Thread.sleep()、Thread.yield()，则当前线程不会释放同步锁；
（2）、程序执行同步方法或同步代码块时，其它线程调用了该线程的suspend()方法将该线程挂起，该线程同样不会释放同步锁（当然，应尽量避免使用suspend()与resume()方法控制线程）。
说明：第（2）条应该不太会出现，因为同步方法或同步代码块中一般不会调用其它线程A，且调用的线程A的run或call方法中又调用了当前线程的suspend方法。
2、会释放同步监视器的几种情况
（1）、同步方法或同步块正常执行完；
（2）、同步方法或同步块中执行了break 或return 时（其实同样属于第（1）种）；
（3）、同步方法或同步块中出现了未处理的异常（Exception）或错误（Error）；
（4）、同步方法或同步块中执行了当前线程的wait()方法。
记忆方法：
不会释放同步监视器的3个方法：sleep、yield、suspend。
二、使用同步锁（Lock）
简介：
Lock 同步锁除了提供synchronized 关键字相同的功能外，还扩展了一些其它功能，使同步访问更加灵活。同步锁从java5开始引入，提供了Lock 与 ReadWriteLock 两个接口，并为Lock 接口提供了ReentrantLock 实现类，为ReadWriteLock 接口提供了ReentrantReadWriteLock 实现类。java8 中有加入了StampedLock 类。
1、Lock 接口
接口方法：
//获得锁（即获得执行权） void lock(); //获得锁，除非当前线程被阻塞 void lockInterruptibly() throws InterruptedException; //仅仅在锁是空闲时可获得锁(返回结果表示是否已获得) boolean tryLock(); //在tryLock基础上指定多长时间内一直尝试获取 boolean tryLock(long time, TimeUnit unit) throws InterruptedException; //释放锁 void unlock(); 说明：tryLock([...]) 已经尝试获得锁了，所以不能再根据其返回结果调用lock()或unLock()。
实现类：
（1）、ReentrantLock 类。
可重入锁，即再已经锁定的代码块内，可以嵌套锁定或调用此锁锁定的其它方法（道理一样）。示例：
import java.util.concurrent.locks.ReentrantLock; public class TestLock { public static void main(String[] args) { new MyThread().start(); } } class MyThread extends Thread{ ReentrantLock myLock = new ReentrantLock(); public void run(){ myLock.lock(); try{ for(int i=0;i<10;i++){ printInt(i); } }finally{ myLock.unlock(); } } private void printInt(int i){ myLock.lock(); System.out.println("被锁住的方法:"+i); myLock.unlock(); } } 2、ReadWriteLock 接口
接口方法：
//返回用于读的锁 Lock readLock(); //返回用于写的锁 Lock writeLock(); 实现类：
ReentrantReadWriteLock 类
可重入读写锁，作用和普通锁差不多，是一个工具类，里面包装了两个Lock 实现类（以内部类形式），即ReadLock 与WriteLock 类。此外，该类提供了获取锁定数目的方法getReadHoldCount()、getWriteHoldCount() 等。示例：
import java.util.concurrent.locks.ReentrantReadWriteLock; public class TestLock { public static void main(String[] args) { new MyThread().start(); } } class MyThread extends Thread{ ReentrantReadWriteLock myLock = new ReentrantReadWriteLock(); public void run(){ myLock.readLock().lock(); System.out.println(myLock.getReadHoldCount());//打印1 try{ myLock.readLock().lock(); System.out.println(myLock.getReadHoldCount());//打印2 myLock.readLock().unlock(); System.out.println(myLock.getReadHoldCount());//打印1 }finally{ myLock.readLock().unlock(); } } } 3、StampedLock 类
方法：
提供了与ReentrantReadWriteLock 类相似的方法，同样以内部类形式包装了两个Lock 实现类（ReadLock 与WriteLock ）可用于获得该对象当前持有锁的数量，只是所持有的锁都是按long 类型数值来标志的，所以，StampedLock 类可用于替换ReentrantLock 类。示例：
class MyThread extends Thread{ StampedLock stampedLock = new StampedLock(); public void run(){ long rl = stampedLock.readLock();//返回一个邮戳用于标志该锁 System.out.println(rl); System.out.println(stampedLock.getReadLockCount());//打印1 stampedLock.unlock(rl);//通过邮戳释放该锁 System.out.println("释放后"+stampedLock.getReadLockCount());//打印0 } } 说明：锁必须被释放，对于可重入锁，其释放顺序为锁定的相反顺序，即较外层的较后释放。
注：文件读写涉及到专门的文件锁，另一篇单独学习：url
三、死锁
当两个线程互相等待对方释放同步监视器时，即出现了死锁，程序无法继续向下执行，也不会报错。
思路示例：
class A{ public synchronized void methodOne(){ //同步方法Aone } public synchronized void methodTwo(){ //同步方法Atwo } } class B{ public synchronized void methodOne(){ //同步方法Bone } public synchronized void methodTwo(){ //同步方法Btwo } } 死锁出现情形分析：
首先，类A与类B中两个方法都为同步方法，即监视器为类的实例，所以同一时刻，只有一个实例执行同步方法，且该实例执行此方法时，不能再任何地方执行其它方法（包括被其他类调用执行），因为该实例作为监视器被正在执行的同步方法持有。死锁出现的关键在于，若一个同步方法被阻塞，则执行该方法的实例将不能再执行其它同步方法。
具体例子：
public class TestSynchronized { public static void main(String[] args) { A a = new A(); B b = new B(); a.setB(b); b.setA(a); ThreadA threadA = new ThreadA(a); ThreadB threadB = new ThreadB(b); threadA.start(); try { //保证threadA先执行，加个50ms延时 Thread.sleep(50); } catch (InterruptedException e) { e.printStackTrace(); } threadB.start(); } } class A{ private B b; public void setB(B b){ this.b = b; } public synchronized void methodOne(){ System.out.println("Aone"); try { System.out.println("A线程睡眠"); Thread.sleep(200); System.out.println("A线程醒来"); } catch (InterruptedException e) { e.printStackTrace(); } //此时监视器b因为其methodOne方法中的sleep而阻塞，methodTwo无法获得监视器b，将等待 b.methodTwo(); } public synchronized void methodTwo(){ System.out.println("Atwo"); } } class B{ private A a; public void setA(A a){ this.a = a; } public synchronized void methodOne(){ System.out.println("Bone"); try { System.out.println("B线程睡眠"); Thread.sleep(200); System.out.println("B线程醒来"); } catch (InterruptedException e) { e.printStackTrace(); } //此线程醒来，此时监视器a在线程A中正在请求b实例的methodTwo方法，所以下面调用将等待 a.methodTwo(); } public synchronized void methodTwo(){ System.out.println("Btwo"); } } class ThreadA extends Thread{ private A a; public ThreadA(A a){ this.a = a; } public void run(){ a.methodOne(); } } class ThreadB extends Thread{ private B b; public ThreadB(B b){ this.b = b; } public void run(){ b.methodOne(); } } 例子说明：
例子中，A的实例a对应线程A，B的实例b对应线程B，死锁范围是指任意两个线程间，而非同一个线程类的两个实例简。例子中死锁出现过程：线程A执行a的methodOne同步方法——>线程A沉睡200ms，监视器a被methodOne持有——>线程A沉睡时线程B执行b的methodOne同步方法——>线程B沉睡200ms，监视器b被methodOne持有——>线程A醒来，执行b的methodTwo同步方法，但无法获得监视器b，等待——>线程B醒来，执行a的methodTwo同步方法，但无法获得监视器a，等待。
例子运行结果：
Aone A线程睡眠 Bone B线程睡眠 A线程醒来 B线程醒来 要解决此问题，可从两方面入手：
一是将methodTwo 都改为非同步的；二是将去掉methodOne 中的sleep()，让其一步执行完此方法。
方法一结果：
Aone A线程睡眠 Bone B线程睡眠 A线程醒来 Btwo B线程醒来 Atwo
方法二结果：
Aone Btwo Bone Atwo
推荐方法一，因为方法二其实是不正确的，因为程序运行并不是以方法为单位，所以当methodOne 方法体较大时，可能还来不及执行完便失去了cpu资源，让给线程B执行，这时还是会出现死锁。如将：
try { System.out.println("B线程睡眠"); Thread.sleep(200); System.out.println("B线程醒来"); } catch (InterruptedException e) { e.printStackTrace(); }改为：
for(int i=0;i<5000;i++){ System.out.println("B(或A)："+i); } 则其中一次执行结果为：
Aone A：0 A：1 A：2
...
A：3052
Bone
B：0
A：3053
B：1
A：3054
...
A：4999
B：2
B：3
...
B：4999
还是出现了死锁（没有打印Atwo 与Btwo ）。当循环次数较小时，出现此问题可能性较小。
所以，不同线程的同步方法间互相调用时，务必多注意！！！
