synchronized关键字的详细分析和代码实例

　　在Java中，一般都是通过同步机制来解决线程安全问题的，在JDK 5.0之后又新增了Lock的方式来实现线程安全。所以说实现线程安全方式一共有三种方法

方式一：

synchronized(同步监视器){

　　//需要被同步的代码(操作共享数据的代码就是需要被同步的代码)

}

通过继承Thread类的方式实现多线程并解决线程安全问题：

 package com.baozi.java;

 public class WinowTest {
     public static void main(String[] args){
         Window w1=new Window();
         Window w2=new Window();
         Window w3=new Window();
         w1.start();
         w2.start();
         w3.start();
     }
 }
 //通过继承Thread类的方法来实现多线程
 class Window extends Thread {
     private static int ticket = 100;
     @Override
     public void run() {
         while (true) {
             //这里通过synchronized代码块的形式来实现线程安全
             synchronized (Window.class) {
                 if (ticket > 0) {
                     try {
                         Thread.sleep(100);
                     } catch (InterruptedException e) {
                         e.printStackTrace();
                     }
                     System.out.println(Thread.currentThread().getName() + ":" + ticket--);
                 } else {
                     break;
                 }
             }
         }

     }
 }

通过实现Runnable接口的方式实现多线程并解决线程安全问题：

 package com.baozi.java;

 public class WindowTest2 {
     public static void main(String[] args){
         Window2 window2 = new Window2();
         Thread t1 = new Thread(window2);
         Thread t2 = new Thread(window2);
         t1.setName("线程1");
         t2.setName("线程2");
         t1.start();
         t2.start();
     }

 }
 //通过实现Runnable接口的方式实现多线程
 class Window2 implements Runnable{
     private  int ticket = 100;
     @Override
     public void run() {
         while (true) {
             //这里通过synchronized代码块的形式来实现线程安全
             synchronized (this) {
                 if (ticket > 0) {
                     try {
                         Thread.sleep(100);
                     } catch (InterruptedException e) {
                         e.printStackTrace();
                     }
                     System.out.println(Thread.currentThread().getName() + ":" + ticket--);
                 } else {
                     break;
                 }
             }
         }

     }
 }

备注：

　　同步监视器：其实就是我们平时说的锁，任何一个类对象都可以充当同步监视器，并且针对需要操作的共享数据，要求多个线程必须共享同一个同步监视器，这样才能实现多线程共享数据的线程安全。

　　同步方法解决了线程安全问题，但是在操作同步代码块的时候，实质上某一时刻只有一个线程拥有锁，其他线程需要操作共享数据的时候只能等待该线程释放了所之后通过抢占方式获得锁之后才能执行。言外之意针对共享数据其实是单线程执行，这样会造成效率非常低。

方式二:

如果多个线程操作的共享数据的代码完整的声明在一个方法中，那么我们使用synchronized关键字修饰这个方法为同步方法。

通过继承Thread类的方式实现多线程并解决线程安全问题：

 package com.baozi.java;

 public class WindowTest3 {
     public static void main(String[] args) {
         Window3 w1 = new Window3();
         Window3 w2 = new Window3();
         Window3 w3 = new Window3();
         w1.start();
         w2.start();
         w3.start();
     }
 }

 //通过继承Thread类的方法来实现多线程
 class Window3 extends Thread {
     private static int ticket = 100;

     @Override
     public void run() {
         while (true) {
             show();
         }
     }

     //这里通过synchronized方法的形式来实现线程安全
     public static synchronized void show() {
         if (ticket > 0) {
             try {
                 Thread.sleep(100);
             } catch (InterruptedException e) {
                 e.printStackTrace();
             }
             System.out.println(Thread.currentThread().getName() + ":" + ticket--);
         }
     }
 }

通过实现Runnable接口的方式实现多线程并解决线程安全问题：

 package com.baozi.java;

 public class WindowTest2 {
     public static void main(String[] args) {
         Window2 window2 = new Window2();
         Thread t1 = new Thread(window2);
         Thread t2 = new Thread(window2);
         t1.setName("线程1");
         t2.setName("线程2");
         t1.start();
         t2.start();
     }
 }
 //通过实现Runnable接口的方式实现多线程
 class Window2 implements Runnable {
     private int ticket = 100;

     @Override
     public synchronized void run() {
         while (true) {
             if (ticket > 0) {
                 try {
                     Thread.sleep(100);
                 } catch (InterruptedException e) {
                     e.printStackTrace();
                 }
                 System.out.println(Thread.currentThread().getName() + ":" + ticket--);
             } else {
                 break;
             }
         }
     }
 }

备注：同步方法依然会涉及到同步监视器，只是不需要我么显示的声明。

　　非静态的同步方法：同步监视器可以是this（当前对象）

　　静态的同步方法：同步监视器可以是当前类

这样我们就能省去单独造一个对象来充当同步监视器，使代码比较简单整洁。

方式三：

使用Lock锁的方式实现线程安全，这是JDK5.0新增加的方法，在后边单独分析。