关键字Synchronized:
当使用Synchrnized (o) ，锁定 o 的时候，锁定的是 o 指向的堆内存中 new 出来的对象，而非 o 引用，当锁定 o 以后，一旦 o 指向了其他对象，这个时候锁定的对象也会发生改变。在工作开发中经常 new 出一个对象当锁太麻烦了，常用的方法是锁定执行方法的对象，即 Synchronized (this)。任何线程要执行同步的代码，必须先获得 this 的锁。锁定 this 对象还有一种写法就是写在方法申明上 public synchronized void method(){} .需要注意的是对于静态（static）方法中不可以使用Synchronized (this)，因为静态的属性或方法不需要 new 出来对象来访问的，也就是没有 this 引用的存在 。Synchronized所同步的代码块越少越好，细粒度的锁能提高效率 下面看一些例子要进一步认识Synchronized。
public class Test5 implements Runnable{
private int count =10;
@Override
public /*synchronized*/ void run() {// synchronized的代码块是原子操作，不可分，只要当前线程操作完了，其他线程才能访问
count --;
// 线程重入 当线程1执行到这里，线程2，3.。也执行到这里，所有控制台有可能输出不一致问题。控制台打印如下。
// Thread0count:8
// Thread4count:5
// Thread2count:6
// Thread1count:8
// Thread3count:7
System.err.println(Thread.currentThread().getName()+ "count:"+count);
}
public static void main(String[] args) {
Test5 t =new Test5();
for(int i=0;i<5;i++) {
new Thread(t,"Thread"+i ).start();
}
}
}
要解决以上线程重入，只需要在方法上添加关键字Synchronized 即可。 因为Synchronized的代码块是原子操作，不可分，不可以被打断。就能避免线程重入。
public class Test6{
public synchronized void m1() {
System.err.println(Thread.currentThread().getName()+ "m1 start:");
try {
Thread.sleep(10000);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
System.err.println(Thread.currentThread().getName()+ "m1 end:");
}
public void m2() {
System.err.println(Thread.currentThread().getName()+ "m2 start:");
try {
Thread.sleep(5000);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
System.err.println(Thread.currentThread().getName()+ "m2 end:");
}
public static void main(String[] args) {
Test6 t =new Test6();
//再调用m1的过程之中能否访问m2 当然可以
new Thread(t::m1,"t1").start();
new Thread(t::m2,"t2").start();
}
}
上面这个小例子要说明的是，当同步方法被调用的过程中能否调用非同步方法，通过执行以上代码可以发现，是可以的。
public class Account{
String name;
double balance;
public synchronized void set(String name ,double balance) {
this.name=name;
try { // 放大线程执行的时间差，表明有可能在执行过程中有其他线程来通过getBalance（）方法获取balance；
Thread.sleep(2000);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
this.balance=balance;
}
public double getBalance(String name) {
return this.balance;
}
public static void main(String[] args) {
Account a =new Account();
new Thread(()->a.set("zhangsan",100.0)).start();
try {
TimeUnit.SECONDS.sleep(1);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
System.out.println(a.getBalance("zhangsan"));
try {
TimeUnit.SECONDS.sleep(2);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
System.out.println(a.getBalance("zhangsan"));
}
}
上述代码对业务写方法加锁，读方法不加锁，容易造成脏读，要解决以上问题，只要在getBalance()上加Synchronized就可以。
public class Test7{
public synchronized void m1() {
System.err.println(Thread.currentThread().getName()+ "m1 start:");
try {
TimeUnit.SECONDS.sleep(1);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
m2();
}
public synchronized void m2() {
System.err.println(Thread.currentThread().getName()+ "m2 start:");
try {
TimeUnit.SECONDS.sleep(2);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
System.err.println(Thread.currentThread().getName()+ "m2 end:");
}
public static void main(String[] args) {
Test7 t =new Test7();
//再调用m1的过程之中能否访问m2 当然可以
new Thread(t::m1,"t1").start();
}
}
上诉代码阐述了一个问题，一个同步方法可以调用另外一个同步方法，一个线程已经拥有某个对象的锁，再次申请的时候还会得到该对象的锁，也就是说synchronized的锁是可以重入的。由于这里锁定是同一个对象this.所以不会产生死锁，产生死锁的情况有很多，其中最简单的一种情况入下：
public static void main(String[] args) {
Object a =new Object();
Object b =new Object();
new Thread(()->{
synchronized(a) {
System.out.println("锁定a");
try {
TimeUnit.SECONDS.sleep(2000);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
synchronized(b) {
System.out.println("锁定b");
}
}
},"t1").start();
new Thread(()->{
synchronized(b) {
System.out.println("锁定b");
synchronized(a) {
System.out.println("锁定a");
}
}
},"t2").start();
}
重入锁还有另外一种情形，即子类的同步方法调用父类的同步方法，其本职也是锁定this对象。代码如下：
public class Test8{
public synchronized void m1() {
System.err.println( "m1 start:");
try {
TimeUnit.SECONDS.sleep(1);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
System.err.println( "m1 end:");
}
public static void main(String[] args) {
new TT().m1();;
}
}
class TT extends Test8{
@Override
public synchronized void m1() {
System.err.println( " child m1 start:");
super.m1();
System.err.println( " child m1 end:");
}
}
下面来看一下另外一个问题，当线程在执行过程中如果有异常抛出的话会产生什么样的后果呢？
public class Test9{
int count =0;
public synchronized void m1() {
System.err.println(Thread.currentThread().getName()+ " start:");
while(true) {
count ++;
System.err.println(Thread.currentThread().getName()+ " count :"+count);
try {
TimeUnit.SECONDS.sleep(1);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
if(count ==5) {
int i=1/0;
}
}
}
public static void main(String[] args) {
Test9 t =new Test9();
//再调用m1的过程之中能否访问m2 当然可以
new Thread(t::m1,"t1").start();
try {
TimeUnit.SECONDS.sleep(3);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
new Thread(t::m1,"t2").start();
}
}
上述代码执行过程中抛出了 ArithmeticException ，抛出异常后该线程立马会释放锁。可以看到运行该程序后，在异常抛出后，t2线程会执行，即证明了t1释放锁。然后t2会拿着t1执行了一半的数据再去处理自己的业务，在程序中这样会发生很严重的数据问题。所以在同步方法内如果会抛出异常，一定要堆异常进行适当的处理，避免类似问题的出现。
public class Test12 {
Object o = new Object();
void m() {//
synchronized (o) {//锁的是堆内存里new出来的对象，一旦o指向了另外的对象，那么原来的锁将被释放
while (true) {
try {
TimeUnit.SECONDS.sleep(1);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.err.println(Thread.currentThread().getName() );
}
}
}
public static void main(String[] args) {
Test12 t = new Test12();
new Thread(t::m,"t1").start();//启动第一个线程
try {
TimeUnit.SECONDS.sleep(2);
} catch (InterruptedException e) {
e.printStackTrace();
}
//启动第二个线程
Thread t2 = new Thread(t::m,"t2");//锁对象发生改变 t2才能执行
t.o =new Object();
t2.start();
}
}
上述小程序描述了synchronized 锁，锁的是堆内存里new出来的对象，一旦o指向了另外的对象，那么原来的锁将被释放，通过上述小程序运行发现当执行完t.o =new Object(); t2线程会随即运行，不然一定要等t1线程释放锁t2才得以运行。
注释掉 t.o =new Object(); 会发现t2是无法运行的。
关键字 Volatile :
先来看一下一段小程序：
public class Test10{
/*volatile*/ boolean running =true; //对比有无 volatile的情况下，整个程序的执行结果
public synchronized void m1() {
System.err.println(Thread.currentThread().getName()+ " start:");
while(running) {
}
System.err.println(Thread.currentThread().getName()+ " end:");
}
public static void main(String[] args) {
Test10 t =new Test10();
new Thread(t::m1,"t1").start();
try {
TimeUnit.SECONDS.sleep(1);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
t.running=false;
}
}
执行小程序，我们会发现在没有 volatile 的情况下，程序一直会处于运行的情况，也就是其中变量running一直是 true 的状态，从而导致方法 m1 一直处于死循环的状态，当加上了关键字 volatile 后，程序会结束，这是为什么呢？ 其实这其中就涉及了线程中 running 这个变量可见性的问题，也就是线程之间的通讯问题，这里涉及到 JAVA 对于线程处理的内存模型（Java Memory Model），在Java Memory Model里面有一个内存叫主内存，我们所说的栈内存，堆内存，都可以认为是主内存，每一个线程在执行的过程中，都会有自己的一块内存，而这块内存不是真正的内存，实际上是CPU上的一块缓冲区，其实就是存放线程自己的变量的一块内存区，它的作用是在线程运行时，将主内存中的内容读过来在缓冲区内做修改，执行完修改动作了再将结果写回到主内存。但是在处理的过程中线程不会再去到主内存中读取该内容，上述代码中由于while死循环使得CPU非常的繁忙，他就不再去主内存中读取running的值，而是直接再自己的缓冲区中读取该变量的值，但是在其他情况下，当CPU并不是那么的繁忙的时候，还是会去读一下的。主线程把 running 改成了 false ，但是t1 线程没有去主内存中重新获取running的值，由于缓冲区中running的值是true，所以导致线程一直处于死循环。加了 volatile 之后，在 running 的值发生了改变，会通知其他线程 ，你们的缓冲区中 running 的值过期了，这个时候，其他线程才会去主内存中重新获取 running 的值，从而才能使线程结束。
如果不使用 volatile 的话，可以使用 synchornized ，但是性能方面会大幅度降低， volatile 的性能比 synchronized的性能要好得多。volatile 可以说使无锁同步，使得两个线程之前的变量的可见性。
volatile不能保证多个线程共同修改running的值带来的不一致问题，也就是说 volatile 不能代替 synchronized ，synchronized即保证了原子性，也保证了可见性，而volatile仅仅保证了可见性，来看一下下一个小程序：
public class Test11{
volatile int count =0;//只保证可见性
void m() {
for(int i=0;i<10000;i++) {
count ++;
}
}
public static void main(String[] args) {
Test11 t =new Test11();
List<Thread> threads =new ArrayList<Thread>();
for(int i=0;i<10;i++) {
threads.add(new Thread(t::m,"thread"+i));
}
threads.forEach((o)->o.start());
threads.forEach((o)->{
try {
o.join();
} catch (InterruptedException e) {
e.printStackTrace();
}
});
System.out.println(t.count);
}
}
理论上上述小程序输出的结果会是100000，但是结果并不是如此，为什么会这样呢？ 因为volatile 仅仅保证可见性，当两个线程同时读取到count为 10的时候，线程1 对count 执行完++ 以后，将11写回，此刻线程2也将自己的++以后的结果写回，这个时候就会出现这种问题，线程2覆盖了线程1 的结果。实际上就加了一遍，如果有多个线程，可能发生多次覆盖。要解决这个问题，可以使用 synchronized ，在方法 m 前 加上synchronized，去掉 count 的volatile即可。如果程序中仅仅涉及数字的简单加减。可以使用JAVA提供的原子类 AtomicXXX来进行操作。因为AtomicXXX这些类所提供的方法都是原子性的，但是AtomicXXX类两个方法之间是不具备原子性的,比如AtomicInteger 的++ 可以使用incrementAndGet（）方法等等。修改以上代码如下：
public class Test11{
// /*volatile*/ int count =0;//只保证可见性
AtomicInteger count =new AtomicInteger(0);
// AtomicBoolean ,AtomicLong
/*synchronized*/ void m() {
for(int i=0;i<10000;i++) {
//count ++;
//if count.get() <1000 再这句中间和下面一行代码之间是不具备原子性的
count.incrementAndGet();// 具备原子性 代替count++
}
}
public static void main(String[] args) {
Test11 t =new Test11();
List<Thread> threads =new ArrayList<Thread>();
for(int i=0;i<10;i++) {
threads.add(new Thread(t::m,"thread"+i));
}
threads.forEach((o)->o.start());
threads.forEach((o)->{
try {
o.join();
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
});
System.out.println(t.count);
}
}