首页技术文章正文

Java同步关键词解释

更新时间:2018-09-14 来源:黑马程序员 浏览量:

1.2. java同步关键词解释
1.2.1. synchronized

        在多个线程同时操作一个成员变量的时候,会出现多线程的安全问题,也就是某几个线程得到的变量在同一时间是相同的,导致计算的不准确。

        针对多线程安全问题的原因,我们需要给出相应的处理方案,针对CPU的切换,由操作系统去控制,而我们认为是无法干预。因此这个问题解决不了。所以要解决安全问题,可以认为的控制CPU在执行某个线程操作共享数据的时候,不让其他线程进入到操作共享数据的代码中去,这样就可以保证安全。

        上述的这个解决方案:称为线程的同步。

        要想保证线程的安全:需要在操作共享数据的地方,加上线程的同步。

        加同步格式:

                synchronized( 需要一个任意的对象(锁) ){

                        代码块中放操作共享数据的代码。

                }

        上述的格式称为多线程中的同步代码块。

        同步代码块上的锁,可以是随便任意的一个对象。

1.2.2. lock

一.synchronized的缺陷

  synchronized是java中的一个关键字,也就是说是Java语言内置的特性。那么为什么会出现Lock呢?

        如果一个代码块被synchronized修饰了,当一个线程获取了对应的锁,并执行该代码块时,其他线程便只能一直等待,等待获取锁的线程释放锁,而这里获取锁的线程释放锁只会有两种情况:

  1)获取锁的线程执行完了该代码块,然后线程释放对锁的占有;

  2)线程执行发生异常,此时JVM会让线程自动释放锁。

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

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

再举个例子:当有多个线程读写文件时,读操作和写操作会发生冲突现象,写操作和写操作会发生冲突现象,但是读操作和读操作不会发生冲突现象。

  但是采用synchronized关键字来实现同步的话,就会导致一个问题:

  如果多个线程都只是进行读操作,所以当一个线程在进行读操作时,其他线程只能等待无法进行读操作。

  因此就需要一种机制来使得多个线程都只是进行读操作时,线程之间不会发生冲突,通过Lock就可以办到。

  另外,通过Lock可以知道线程有没有成功获取到锁。这个是synchronized无法办到的。

  总的来说,也就是说Lock提供了比synchronized更多的功能。但是要注意以下几点:

  1)Lock不是Java语言内置的,synchronized是Java语言的关键字,因此是内置特性。Lock是一个类,通过这个类可以实现同步访问;

  2)Lock和synchronized有一点非常大的不同,采用synchronized不需要用户去手动释放锁,当synchronized方法或者synchronized代码块执行完之后,系统会自动让线程释放对锁的占用;而Lock则必须要用户去手动释放锁,如果没有主动释放锁,就有可能导致出现死锁现象。

二.java.util.concurrent.locks包下常用的类

  下面我们就来探讨一下java.util.concurrent.locks包中常用的类和接口。

  1.Lock

  首先要说明的就是Lock,通过查看Lock的源码可知,Lock是一个接口:

public interface Lock {

    void lock();

    void lockInterruptibly() throws InterruptedException;

    boolean tryLock();

    boolean tryLock(long time, TimeUnit unit) throws InterruptedException;

    void unlock();

    Condition newCondition();

}

   

  下面来逐个讲述Lock接口中每个方法的使用,lock()、tryLock()、tryLock(long time, TimeUnit unit)和lockInterruptibly()是用来获取锁的。unLock()方法是用来释放锁的。newCondition()这个方法暂且不在此讲述,会在后面的线程协作一文中讲述。

  在Lock中声明了四个方法来获取锁,那么这四个方法有何区别呢?

  首先lock()方法是平常使用得最多的一个方法,就是用来获取锁。如果锁已被其他线程获取,则进行等待。

  由于在前面讲到如果采用Lock,必须主动去释放锁,并且在发生异常时,不会自动释放锁。因此一般来说,使用Lock必须在try{}catch{}块中进行,并且将释放锁的操作放在finally块中进行,以保证锁一定被被释放,防止死锁的发生。通常使用Lock来进行同步的话,是以下面这种形式去使用的:

Lock lock = ...;

lock.lock();

try{

    //处理任务

}catch(Exception ex){

     

}finally{

    lock.unlock();   //释放锁

}

   

  tryLock()方法是有返回值的,它表示用来尝试获取锁,如果获取成功,则返回true,如果获取失败(即锁已被其他线程获取),则返回false,也就说这个方法无论如何都会立即返回。在拿不到锁时不会一直在那等待。

  tryLock(long time, TimeUnit unit)方法和tryLock()方法是类似的,只不过区别在于这个方法在拿不到锁时会等待一定的时间,在时间期限之内如果还拿不到锁,就返回false。如果如果一开始拿到锁或者在等待期间内拿到了锁,则返回true。

所以,一般情况下通过tryLock来获取锁时是这样使用的:

Lock lock = ...;

if(lock.tryLock()) {

     try{

         //处理任务

     }catch(Exception ex){

         

     }finally{

         lock.unlock();   //释放锁

     }

}else {

    //如果不能获取锁,则直接做其他事情

}

   

  lockInterruptibly()方法比较特殊,当通过这个方法去获取锁时,如果线程正在等待获取锁,则这个线程能够响应中断,即中断线程的等待状态。也就使说,当两个线程同时通过lock.lockInterruptibly()想获取某个锁时,假若此时线程A获取到了锁,而线程B只有在等待,那么对线程B调用threadB.interrupt()方法能够中断线程B的等待过程。

  由于lockInterruptibly()的声明中抛出了异常,所以lock.lockInterruptibly()必须放在try块中或者在调用lockInterruptibly()的方法外声明抛出InterruptedException。

  因此lockInterruptibly()一般的使用形式如下:

public void method() throws InterruptedException {

    lock.lockInterruptibly();

    try {  

     //.....

    }

    finally {

        lock.unlock();

    }  

}

   

  注意,当一个线程获取了锁之后,是不会被interrupt()方法中断的。因为本身在前面的文章中讲过单独调用interrupt()方法不能中断正在运行过程中的线程,只能中断阻塞过程中的线程。

  因此当通过lockInterruptibly()方法获取某个锁时,如果不能获取到,只有进行等待的情况下,是可以响应中断的。

  而用synchronized修饰的话,当一个线程处于等待某个锁的状态,是无法被中断的,只有一直等待下去。

  2.ReentrantLock

  ReentrantLock,意思是“可重入锁”,关于可重入锁的概念在下一节讲述。ReentrantLock是唯一实现了Lock接口的类,并且ReentrantLock提供了更多的方法。下面通过一些实例看具体看一下如何使用ReentrantLock。

  例子1,lock()的正确使用方法

public class Test {

    private ArrayList<Integer> arrayList = new ArrayList<Integer>();

    public static void main(String[] args)  {

        final Test test = new Test();

         

        new Thread(){

            public void run() {

                test.insert(Thread.currentThread());

            };

        }.start();

         

        new Thread(){

            public void run() {

                test.insert(Thread.currentThread());

            };

        }.start();

    }  

     

    public void insert(Thread thread) {

        Lock lock = new ReentrantLock();    //注意这个地方

        lock.lock();

        try {

            System.out.println(thread.getName()+"得到了锁");

            for(int i=0;i<5;i++) {

                arrayList.add(i);

            }

        } catch (Exception e) {

            // TODO: handle exception

        }finally {

            System.out.println(thread.getName()+"释放了锁");

            lock.unlock();

        }

    }

}

   

输出结果是:

Thread-0得到了锁

Thread-1得到了锁

Thread-0释放了锁

Thread-1释放了锁

  也许有同学会问,怎么会输出这个结果?第二个线程怎么会在第一个线程释放锁之前得到了锁?原因在于,在insert方法中的lock变量是局部变量,每个线程执行该方法时都会保存一个副本,那么理所当然每个线程执行到lock.lock()处获取的是不同的锁,所以就不会发生冲突。


作者:黑马程序员javaEE培训学院
首发:http://java.itheima.com/

分享到:
在线咨询 我要报名
和我们在线交谈!