同步关键词synchronized

概述

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

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

}

 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。

 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更多的功能。

猜你喜欢

转载自www.cnblogs.com/luxd/p/9812107.html