同步关键词synchronized

概述

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

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

}

public synchronized int getIndex() {
        return 1;
    }
    
    public static synchronized int getNext() {
        return 2;
    }
    
    
    public int getPre() {
        
        //这里的参数可以用java所有对象
        //synchronized(this) {
        //synchronized(Demo1.class) {
        synchronized(new Demo1()) {
            System.out.println("synchronized(这里的参数可以用java所有对象)");
        }
        
        return 0;
    }

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

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

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

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

实例

继续卖火车票的例子。

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

如何使顺序有序呢？

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

加synchronize。

package multithreading.sync;
 
public class MyThreadWithImplements implements Runnable {
 
    private int tickets = 10;
 
    @Override
    public synchronized void run() {
 
        for (int i = 0; i <= 100; i++) {
            if(tickets>0){
                System.out.println(Thread.currentThread().getName()+"--卖出票：" + tickets--);
            }
        }
    }
    
    
    public static void main(String[] args) {
        
        MyThreadWithImplements myRunnable = new MyThreadWithImplements();
        Thread thread1 = new Thread(myRunnable, "窗口一");
        Thread thread2 = new Thread(myRunnable, "窗口二");
        Thread thread3 = new Thread(myRunnable, "窗口三");
 
        thread1.start();
        thread2.start();
        thread3.start();
    }
 
}

运行结果

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

缺陷

例子1

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

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

例子2

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

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