详解Java同步—线程锁和条件对象

时间:2022-01-06 14:59:09

线程锁和条件对象

在大多数多线程应用中,都是两个及以上线程需要共享对同一数据的存取,所以有可能出现两个线程同时访问同一个资源的情况,这种情况叫做:竞争条件。

在java中为了解决并发的数据访问问题,一般使用锁这个概念来解决。

有几种机制防止代码收到并发访问的干扰:

1.synchronized关键字(自动创建一个锁及相关的条件)

2.reentrantlock类+java.util.concurrent包中的lock接口(在java5.0的时候引入)

reentrantlock的使用

?
1
2
3
4
5
6
7
8
9
10
11
12
public void method() {
    boolean flag = false;//标识条件
    reentrantlock locker = new reentrantlock();
    locker.lock();//开启线程锁
    try {
      //do some work...
    } catch (exception ex) {
 
    } finally {
      locker.unlock();//解锁线程
    }
  }

locker.lock();确保只有一个线程进入临界区,一旦一个线程进入之后,会获得锁对象,其他线程无法通过lock语句。当其他线程调用lock时,它们会被阻塞,知道第一个线程释放锁对象。

locker.unlock();解锁操作,一定要放到finally里,因为如果try语句里出了问题,锁必须被释放,否则其他线程将永远被阻塞

因为系统会随机为线程分配资源,所以在线程获得锁对象之后,可能被系统剥夺运行权,这时候其他线程来访问,但是发现有锁,进不去,只能等拿到锁对象的线程把里面的代码执行完毕后,释放锁,第二个线程才能运行。

假设说做一个银行转账的功能,线程锁操作应该定义在银行类的转账方法里,因为这样每个银行对象都有一个锁对象,两个线程访问一个银行对象的时候,那么锁以串行方式提供服务。但是,如果每个线程访问不同的银行对象,每个线程都会得到不同的锁对象,彼此之间不会冲突,所以就不会造成不必要的线程阻塞。

锁是可重入的,线程可以重复获得已经持有的锁,锁通过一个持有数量计数来跟踪对lock方法的嵌套使用。

假设说,一个线程获得锁之后,要执行a方法,但是a方法里面又调用了b方法,这时候这个线程获得了两个锁对象,当线程执行b方法的时候,也会被锁死,防止其他线程乱入,当b方法执行完毕后,锁对象变成了一个,当a方法也执行完毕的时候,锁对象变成了0个,线程释放锁。

synchronized关键字

前面我们讲了reentrantlock锁对象的使用,但是在系统里面我们不一定要使用reentrantlock锁,java中还提供了一个内部的隐式锁,关键字是synchronized.

举个例子:

?
1
2
3
public synchronized void method() {
  //do some work...
}

只需要在返回值前面加上synchronized锁,就会实现上面reentrantlock锁同样的效果.

conditional条件对象

通常,线程拿到锁对象之后,却发现需要满足某一条件才能继续向下执行。

拿银行程序来举例子,我们需要转账方账户有足够的资金才能转出到目标账户,这时候需要用到reentrantlock对象,因为如果我们已经完成转账方账户有足够的资金的判断之后,线程被其他线程中断,等其他线程执行完之后,转账方的钱又没有了足够的资金,这时候因为系统已经完成了判断,所以会继续向下执行,然后银行系统就会出现问题。

举例:

?
1
2
3
4
public void transfer(int from, int to, double amount) {
  if (accounts[from] > amount)//系统在结束判断之后被剥夺运行权,然后账户通过网银转出所有钱,银行凉凉
    dotransfer(from, to, amount);
}

这时候我们就需要使用reentrantlock对象了,我们修改一下代码:

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
public void transfer(int from, int to, double amount) {
  reentrantlock locker = new reentrantlock();
  locker.lock();
  try {
    while (accounts[from] < amount) {
      //等待有足够的钱
    }
    dotransfer(from, to, amount);
  } catch (exception ex) {
    ex.printstacktrace();
  } finally {
    locker.unlock();
  }
}

但是这样又有了问题,当前线程获取了锁对象之后,开始执行代码,发现钱不够,进入等待状态,然后其他线程又因为锁的原因无法给该账户转账,就会一直进入等待状态。

这个问题如何解决呢?

条件对象登场!

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
public void transfer(int from, int to, double amount) {
  reentrantlock locker = new reentrantlock();
  condition sufficientfunds = locker.newcondition();//条件对象,
  lock.lock();
  try {
    while (accounts[from] < amount) {
      sufficientfunds.await();
      //等待有足够的钱
    }
    dotransfer(from, to, amount);
    sufficientfunds.signalall();
  } catch (exception ex) {
    ex.printstacktrace();
  } finally {
    locker.unlock();
  }
}

条件对象的关键字是:condition,一个锁对象可以有一个或多个相关的条件对象。可以通过锁对象.newcondition方法获得一个条件对象.

一般关于条件对象的命名需要能够反映它表达的条件的名字,所以在这里我们叫他sufficientfund,表示余额充足的意思。

在进入锁之前,我们创建一个条件,然后如果金额不足,在这里调用条件对象的await方法,通知系统当前线程进入挂起状态,让其他线程执行。这样你这次调用会被锁定,然后系统可以再次调用该方法给其他账户转账,当每一次转账完成后,执行转账操作的线程在底部调用signalall通知所有线程可以继续运行了,因为我们有可能是转足够的钱给当前账户,这时候有可能该线程会继续执行(不一定是你,是通知所有线程,如果通知的线程还是不符合条件,会继续调用await方法,并完成转账操作,然后通知其他挂起的线程。

你说为啥不直接通知当前线程?不行,可以调用signal方法只通知一个线程,但是如果这个线程操作的账户还是没钱(不是转账给这个账户的情况),那这个线程又进入等待了,这时候已经没有线程能通知其他线程了,程序死锁,所以还是用signal比较保险。

以上是使用reentrantlock+condition对象,那你说我要是使用synchronized隐式锁怎么办?

也可以,而且不需要

?
1
2
3
4
5
6
7
8
public void transfer(int from, int to, double amount) {
   while (accounts[from] < amount) {
      wait();//这个wait方法是定义在object类里面的,可以直接用,和条件对象的await一样,挂起线程
      //等待有足够的钱
    }
    dotransfer(from, to, amount);
    notifyall();//通知其他挂起的线程
}

object类里面定义了wait、notifyall、notify方法,对应await、signalall和signal方法,用来操作隐式锁,synchronized只能有一个条件,而reentrantlock显式声明的锁可以用绑定多个condition条件.

同步块

除了我们上面讲的两种获取线程锁的方式,还有另外一种机制获得锁,这种方式比较特殊,叫做同步块:

?
1
2
3
4
5
6
7
8
9
object locker = new object();
synchronized (locker) {
  //do some work
}
 
//也可以直接锁当前类的对象
sychronized(this){
  //do some work
}

以上代码会获得object类型locker对象的锁,这种锁是一个特殊的锁,在上面的代码中,创建这个object类对象只是单纯用来使用其持有的锁.

这种机制叫做同步块,应用场景也很广:有的时候,我们并不是整个一个方法都需要同步,只是方法里的部分代码块需要同步,这种情况下,我们如果将这个方法声明为synchronized,尤其是方法很大的时候,会造成很大的资源浪费。所以在这种情况下我们可以使用synchronized关键字来声明同步块:

?
1
2
3
4
5
6
public void method() {
  //do some work without synchronized
  synchronized (this) {
    //do some synchronized operation
  }
}

监视器的概念

锁和条件是同步中一个很重要的工具,但是它们并不是面向对象的。多年来,java的研究人员努力寻找一种方法,可以在不需要考虑如何加锁的情况下,就能保证多线程的安全性。最成功的的一个解决方案叫做monitor监视器,这个对象内置于每一个object变量中,相当于一个许可证。拿到许可证就可以进行操作,没有拿到则需要阻塞等待。

监视器具有以下特性:

1.监视器是只包含私有域的类

2.每个监视器对象都有一个相关的锁

3.使用监视器对象的锁对所有的方法进行加锁(举个例子:如果调用obj.method方法,obj对象的锁会在方法调用的时候自动获得,当方法结束或返回之后会自动释放该锁。因为所有的域都是私有的,这样可以确保一个线程在操作类对象的时候,没有其他线程可以访问里面的域)

4.该锁对象可以有任意多个相关条件

你也可以自己创建一个监视器类,只要符合以上的要求即可。

其实我们使用的synchronized关键字就是使用了monitor来实现加锁解锁,所以又被称为内部锁。因为object类实现了监视器,所以对象又被内置于任何一个对象之中。这就是我们为什么可以使用synchronized(locker)的方式锁定一个代码块了,其实只是用到了locker对象中内置的monitor而已。每一个对象的monitor类又是唯一的,所以就是唯一的许可证,拿到许可证的线程才可以执行,执行完后释放对象的monitor才可以被其他线程获取。

举个例子:

?
1
2
3
synchronized (this) {
  //do some synchronized operation
}

它在字节码文件中会被编译为:

?
1
2
3
monitorenter;//get monitor,enter the synchronized block
      //do some synchronized operation
monitorexit;//leavel the synchronized block,release the monitor

死锁

虽然有了线程可以保证原子性,但是锁和条件不能解决多线程中的所有问题,举个例子:

账户1余额:200

账户2余额:300

线程1:账户1→账户2(300)

线程2:账户2→账户1(400)

因为线程1和线程2的金额都不足以进行转账,所以两个线程都阻塞了,这种状态就叫死锁(deadlock),如果所有线程死锁,程序就卡死了。

为什么倾向于使用signalall和notifyall方式,如果假设使用signal和notify,

锁测试和超时

线程在调用lock方法获得另一个线程持有的锁的时候,很可能发生阻塞。应该更加谨慎的申请锁,trylock方法试图申请一个锁,如果申请成功,返回true,否则,立刻返回false,线程就会离开去做别的事,而不是被阻塞等待锁对象。

语法:

?
1
2
3
4
5
6
7
8
9
10
11
12
reentrantlock locker = new reentrantlock();
if (locker.trylock()) {
  try {
    //do some work
  } catch (exception ex) {
    ex.printstacktrace();
  } finally {
    locker.unlock();
  }
} else {
  //do other work
}

也可以给其指定超时参数,单位有seconds、milliseconds、microseonds和manoseconds.

?
1
2
3
4
5
6
7
8
9
10
11
12
reentrantlock locker = new reentrantlock();
if (locker.trylock(1000, timeunit.milliseconds)) {
  try {
    //do some work
  } catch (exception ex) {
    ex.printstacktrace();
  } finally {
    locker.unlock();
  }
} else {
  //do other work
}

lock方法不能被中断,如果一个线程在调用了lock方法后等待锁的时候被中断,中断线程在获得锁之前一直处于阻塞状态。

如果带有超时参数的trylock方法,那么如果等待期间线程被中断,会抛出interruptedexception异常,这是一个很好的特性,允许程序打破死锁。

读/写锁

reentrantlock类属于java.util.concurrent.locks包,这个包底下还有一个reentrantreaderwriterlock类,如果使用多线程对数据读的操作很多,但是写的操作很少的话,可以使用这个类。

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
private reentrantreadwritelock rwl = new reentrantreadwritelock():
 
public void read() {
  lock readlocker = rwl.readlock();//创建读取锁对象
  readlocker.lock();//使用读取锁对象加锁
  try {
    //do some work
  } catch (exception ex) {
    ex.printstacktrace();
  } finally {
    readlocker.unlock();
  }
}
 
public void write() {
  lock writelocker = rwl.writelock();//创建写入锁对象
  writelocker.lock();//使用写入锁对象加锁
  try {
    //do some work
  } catch (exception ex) {
    ex.printstacktrace();
  } finally {
    writelocker.unlock();
  }
}

原文链接:https://www.cnblogs.com/Fill/p/9379776.html