同步关键词synchronized

概述

synchronized是java中的一个关键字，也就是说是Java语言内置的特性。

synchronized( 一个任意的对象（锁） ){
代码块中放操作共享数据的代码。

}

[java]  view plain  copy

1. public synchronized int getIndex() {  
2.         return 1;  
3.     }  
4.       
5.     public static synchronized int getNext() {  
6.         return 2;  
7.     }  
8.       
9.       
10.     public int getPre() {  
11.           
12.         //这里的参数可以用java所有对象  
13.         //synchronized(this) {  
14.         //synchronized(Demo1.class) {  
15.         synchronized(new Demo1()) {  
16.             System.out.println("synchronized(这里的参数可以用java所有对象)");  
17.         }  
18.           
19.         return 0;  
20.     }  

synchronized 放在普通方法上，内置锁就是当前类的实例。

synchronized 放在静态方法上，内置锁就是当前类的Class字节码对象

如果一个代码块被synchronized修饰了，当一个线程获取了对应的锁，并执行该代码块时，其他线程便只能一直等待，等待获取锁的线程释放锁。这种特性又被称为互斥锁

而这里获取锁的线程释放锁只会有两种情况：
1）获取锁的线程执行完了该代码块，然后线程释放对锁的占有。
2）线程执行发生异常，此时JVM会让线程自动释放锁。

实例

继续卖火车票的例子。

在《Java中Runnable和Thread的区别》火车票例子里，我们看到三个窗口卖出去的火车票，顺序是乱的。

如何使顺序有序呢？

线程执行的时候，一个个执行不就有序了。即线程1在执行的时候，其他线程阻塞不要执行。

加synchronize。

[java]  view plain  copy

1. package multithreading.sync;  
2.   
3. public class MyThreadWithImplements implements Runnable {  
4.   
5.     private int tickets = 10;  
6.   
7.     @Override  
8.     public synchronized void run() {  
9.   
10.         for (int i = 0; i <= 100; i++) {  
11.             if(tickets>0){  
12.                 System.out.println(Thread.currentThread().getName()+"--卖出票：" + tickets--);  
13.             }  
14.         }  
15.     }  
16.       
17.       
18.     public static void main(String[] args) {  
19.           
20.         MyThreadWithImplements myRunnable = new MyThreadWithImplements();  
21.         Thread thread1 = new Thread(myRunnable, "窗口一");  
22.         Thread thread2 = new Thread(myRunnable, "窗口二");  
23.         Thread thread3 = new Thread(myRunnable, "窗口三");  
24.   
25.         thread1.start();  
26.         thread2.start();  
27.         thread3.start();  
28.     }  
29.   
30. }  

运行结果

窗口一--卖出票：10
窗口一--卖出票：9
窗口一--卖出票：8
窗口一--卖出票：7
窗口一--卖出票：6
窗口一--卖出票：5
窗口一--卖出票：4
窗口一--卖出票：3
窗口一--卖出票：2
窗口一--卖出票：1

缺陷

例子1

如果这个获取锁的线程由于要等待IO或者其他原因（比如调用sleep方法）被阻塞了，但是又没有释放锁，其他线程便只能干巴巴地等待，这多么影响程序执行效率。

因此就需要有一种机制可以不让等待的线程一直无期限地等待下去（比如只等待一定的时间或者能够响应中断），通过Lock就可以办到。

例子2

当有多个线程读写文件时，读写操作会发生冲突现象，写写操作会发生冲突现象，但是读读操作不会发生冲突现象。
但是采用synchronized关键字来实现同步的话，就会导致一个问题：
如果多个线程都只是进行读操作，当一个线程在进行读操作时，其他线程只能等待无法进行读操作。

因此就需要一种机制来使得多个线程都只是进行读操作时，线程之间不会发生冲突，通过Lock就可以办到。
另外，通过Lock可以知道线程有没有成功获取到锁。这个是synchronized无法办到的。
总的来说，也就是说Lock提供了比synchronized更多的功能。