Java中级_多线程三

发表于 | 更新于 | 分类于 | 阅读次数：
本文字数： 12k | 阅读时长 ≈ 11 分钟

Lock

java.util.concurrent.locks
Interface Lock

所有已知实现类：
ReentrantLock ， ReentrantReadWriteLock.ReadLock ， ReentrantReadWriteLock.WriteLock

本章主要讲的是ReentrantLock 这个子类

与Snychronized的区别

先看一先Snychronized对锁的把控

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
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
/**
	 * 
	 * @Title: snychronizedTest
	 * @Description:  synchronized的简单演示
	 * @return void 返回类型
	 * @Date 2020年6月16日
	 */
	public static void snychronizedTest() {
		final Object o = new Object();
		new Thread(() -> {
			System.out.println(nowdateTest() + Thread.currentThread().getName() + "开始运行...");
			System.out.println(nowdateTest() + Thread.currentThread().getName() + "试图占有对象...");
			synchronized (o) {
				try {
					System.out.println(nowdateTest() + Thread.currentThread().getName() + "占有对象...");
					Thread.sleep(3000);
					System.out.println(nowdateTest() + Thread.currentThread().getName() + "释放对象");
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
			}
			System.out.println(nowdateTest() + Thread.currentThread().getName() + "线程结束.");
		}, "线程a").start();
		;
		new Thread(() -> {
			System.out.println(nowdateTest() + Thread.currentThread().getName() + "开始运行...");
			System.out.println(nowdateTest() + Thread.currentThread().getName() + "试图占有对象...");
			synchronized (o) {
				try {
					System.out.println(nowdateTest() + Thread.currentThread().getName() + "占有对象...");
					Thread.sleep(3000);
					System.out.println(nowdateTest() + Thread.currentThread().getName() + "释放对象");
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
			}
			System.out.println(nowdateTest() + Thread.currentThread().getName() + "线程结束.");
		}, "线程b").start();
		;
	}

结果:

11:41:35线程a开始运行…
11:41:35线程b开始运行…
11:41:35线程a试图占有对象…
11:41:35线程b试图占有对象…
11:41:35线程a占有对象…
11:41:38线程a释放对象
11:41:38线程a线程结束.
11:41:38线程b占有对象…
11:41:41线程b释放对象
11:41:41线程b线程结束.

接下来就看一下Lock的

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
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
/**
	 * 
	 * @Title: lockTest
	 * @Description: lock(),unlock()
	 * @return void 返回类型
	 * @Date 2020年6月16日
	 */
	public static void lockTest() {
		ReentrantLock lock = new ReentrantLock();
		new Thread(() -> {
			System.out.println(nowdateTest() + Thread.currentThread().getName() + "开始运行...");
			System.out.println(nowdateTest() + Thread.currentThread().getName() + "试图占有对象...");
			lock.lock();
			try {
				System.out.println(nowdateTest() + Thread.currentThread().getName() + "占有对象...");
				Thread.sleep(3000);
				System.out.println(nowdateTest() + Thread.currentThread().getName() + "占有对象完毕");
			} catch (InterruptedException e) {
				e.printStackTrace();
			} finally {
				lock.unlock();
				System.out.println(nowdateTest() + Thread.currentThread().getName() + "释放对象");
			}

			System.out.println(nowdateTest() + Thread.currentThread().getName() + "线程结束.");
		}, "线程a").start();
		;
		new Thread(() -> {
			System.out.println(nowdateTest() + Thread.currentThread().getName() + "开始运行...");
			System.out.println(nowdateTest() + Thread.currentThread().getName() + "试图占有对象...");
			lock.lock();
			try {
				System.out.println(nowdateTest() + Thread.currentThread().getName() + "占有对象...");
				Thread.sleep(3000);
				System.out.println(nowdateTest() + Thread.currentThread().getName() + "占有对象完毕");
			} catch (InterruptedException e) {
				e.printStackTrace();
			} finally {
				lock.unlock();
				System.out.println(nowdateTest() + Thread.currentThread().getName() + "释放对象");
			}
			System.out.println(nowdateTest() + Thread.currentThread().getName() + "线程结束.");
		}, "线程b").start();
		;
	}

结果:

11:40:48线程b开始运行…
11:40:48线程a开始运行…
11:40:48线程b试图占有对象…
11:40:48线程a试图占有对象…
11:40:48线程b占有对象…
11:40:51线程b占有对象完毕
11:40:51线程b释放对象
11:40:51线程a占有对象…
11:40:51线程b线程结束.
11:40:54线程a占有对象完毕
11:40:54线程a释放对象
11:40:54线程a线程结束.

Lock-线程交互

Synchronize中使用是的wait(),notify();

而,Lock使用的子类ReentrantLock并没有这两个方法

但是我们在官网看对Lock接口的介绍 讲到

public interface Lock

Lock实现提供比使用synchronized方法和语句可以获得的更广泛的锁定操作。 它们允许更灵活的结构化，可能具有完全不同的属性，并且可以支持多个相关联的对象Condition

可以看到有这么一个Condition

我们看一下官方对Condition的介绍

public interface Condition

Condition因素出Object监视器方法（ wait ， notify和notifyAll ）成不同的对象，以得到具有多个等待集的每个对象，通过将它们与使用任意的组合的效果Lock个实现。 Lock替换synchronized方法和语句的使用， Condition取代了对象监视器方法的使用。

到这里,可以知道Condition是我们需要的了看一下Conditon的方法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
void await() 
导致当前线程等到发信号或 interrupted 。  
boolean await(long time, TimeUnit unit) 
使当前线程等待直到发出信号或中断，或指定的等待时间过去。  
long awaitNanos(long nanosTimeout) 
使当前线程等待直到发出信号或中断，或指定的等待时间过去。  
void awaitUninterruptibly() 
使当前线程等待直到发出信号。  
boolean awaitUntil(Date deadline) 
使当前线程等待直到发出信号或中断，或者指定的最后期限过去。  
void signal() 
唤醒一个等待线程。  
void signalAll() 
唤醒所有等待线程。

可以看出,对应Synchronized的（ wait ， notify和notifyAll ）的Condition方法是 ( await() , signal() , signalAll() ) ;

再看一下官方给出的用法

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
26
27
28
29
30
31
 class BoundedBuffer {
  final Lock lock = new ReentrantLock();
  final Condition notFull  = lock.newCondition(); 
  final Condition notEmpty = lock.newCondition(); 

  final Object[] items = new Object[100];
  int putptr, takeptr, count;

  public void put(Object x) throws InterruptedException {
    lock.lock(); try {
      while (count == items.length)
        notFull.await();
      items[putptr] = x;
      if (++putptr == items.length) putptr = 0;
      ++count;
      notEmpty.signal();
    } finally { lock.unlock(); }
  }

  public Object take() throws InterruptedException {
    lock.lock(); try {
      while (count == 0)
        notEmpty.await();
      Object x = items[takeptr];
      if (++takeptr == items.length) takeptr = 0;
      --count;
      notFull.signal();
      return x;
    } finally { lock.unlock(); }
  }
}

现在来使用一下

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
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
public static void lockConditonTest() {
		ReentrantLock lock = new ReentrantLock();
		Condition condition = lock.newCondition();
		new Thread(() -> {
			System.out.println(nowdateTest() + Thread.currentThread().getName() + "开始运行...");
			System.out.println(nowdateTest() + Thread.currentThread().getName() + "试图占有对象...");
			lock.lock();
			System.out.println(nowdateTest() + Thread.currentThread().getName() + "占有对象...");
			try {
				Thread.sleep(3000);
				System.out.println(nowdateTest() + Thread.currentThread().getName() + "临时释放对象,并进行等待2s之后的唤醒");
				condition.await(2, TimeUnit.SECONDS);
				System.out.println(nowdateTest() + Thread.currentThread().getName() + "等待结束,重新占有");
				Thread.sleep(2000);
			} catch (InterruptedException e) {
				e.printStackTrace();
			} finally {
				lock.unlock();
				System.out.println(nowdateTest() + Thread.currentThread().getName() + "释放对象");
			}
			
			System.out.println(nowdateTest() + Thread.currentThread().getName() + "线程结束.");
		}, "线程a").start();
		new Thread(() -> {
			System.out.println(nowdateTest() + Thread.currentThread().getName() + "开始运行...");
			System.out.println(nowdateTest() + Thread.currentThread().getName() + "试图占有对象...");
			lock.lock();
			System.out.println(nowdateTest() + Thread.currentThread().getName() + "占有对象...");
			try {
				Thread.sleep(3000);
				System.out.println(nowdateTest() + Thread.currentThread().getName() + "临时释放对象,并唤醒等待线程...");
				condition.signal();
			} catch (InterruptedException e) {
				e.printStackTrace();
			} finally {
				lock.unlock();
				System.out.println(nowdateTest() + Thread.currentThread().getName() + "释放对象");
			}
			System.out.println(nowdateTest() + Thread.currentThread().getName() + "线程结束.");
		}, "线程b").start();
		;
	}

结果:

11:40:03线程a开始运行…
11:40:03线程b开始运行…
11:40:03线程b试图占有对象…
11:40:03线程a试图占有对象…
11:40:03线程b占有对象…
11:40:06线程b临时释放对象,并唤醒等待线程…
11:40:06线程a占有对象…
11:40:06线程b释放对象
11:40:06线程b线程结束.
11:40:09线程a临时释放对象,并进行等待2s之后的唤醒
11:40:11线程a等待结束,重新占有
11:40:13线程a释放对象
11:40:13线程a线程结束.

再介绍一下Lock的非阻塞获取锁的方法

Lock实现提供了使用synchronized方法和语句的附加功能，通过提供非阻塞尝试来获取锁（ tryLock() ），尝试获取可被中断的锁（ lockInterruptibly()） ，以及尝试获取可以超时（ tryLock(long, TimeUnit) ）。

看代码

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
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
public static void trylockTest() {
		ReentrantLock lock = new ReentrantLock();
		new Thread(() -> {
			System.out.println(nowdateTest() + Thread.currentThread().getName() + "开始运行...");
			boolean tryLock = false;
			try {
				System.out.println(nowdateTest() + Thread.currentThread().getName() + "试图占有对象...");
				tryLock = lock.tryLock(2, TimeUnit.SECONDS);
				if (tryLock) {
					System.out.println(nowdateTest() + Thread.currentThread().getName() + "占有对象...");
					Thread.sleep(3000);
					System.out.println(nowdateTest() + Thread.currentThread().getName() + "占有对象完毕");
				} else {
					System.out.println("试图占领失败,撤退");
				}
			} catch (InterruptedException e) {
				e.printStackTrace();
			} finally {
				if (tryLock) {
					lock.unlock();
					System.out.println(nowdateTest() + Thread.currentThread().getName() + "释放对象");
				}
			}
			System.out.println(nowdateTest() + Thread.currentThread().getName() + "线程结束.");
		}, "线程a").start();
		;
		new Thread(() -> {
			System.out.println(nowdateTest() + Thread.currentThread().getName() + "开始运行...");
			boolean tryLock = false;
			try {
				System.out.println(nowdateTest() + Thread.currentThread().getName() + "试图占有对象...");
				tryLock = lock.tryLock(2, TimeUnit.SECONDS);
				if (tryLock) {
					System.out.println(nowdateTest() + Thread.currentThread().getName() + "占有对象...");
					Thread.sleep(3000);
					System.out.println(nowdateTest() + Thread.currentThread().getName() + "占有对象完毕");
				} else {
					System.out.println("试图占领失败,撤退");
				}
			} catch (InterruptedException e) {
				e.printStackTrace();
			} finally {
				if (tryLock) {
					lock.unlock();
					System.out.println(nowdateTest() + Thread.currentThread().getName() + "释放对象");
				}
			}
			System.out.println(nowdateTest() + Thread.currentThread().getName() + "线程结束.");
		}, "线程b").start();
		;
	}

结果:

11:44:47线程b开始运行…
11:44:47线程a开始运行…
11:44:47线程b试图占有对象…
11:44:47线程a试图占有对象…
11:44:47线程a占有对象…
试图占领失败,撤退
11:44:49线程b线程结束.
11:44:50线程a占有对象完毕
11:44:50线程a释放对象
11:44:50线程a线程结束.

对于tryLock() ,在释放锁的时候,一定要判断一下是否拿到了锁,要不然会报java.lang.IllegalMonitorStateException

是不是以为到这里就结束了? 不,没有,

对于多线程,知道这是可以充分利用我们的CPU资源,但是如果多个线程都同时对一个变量进行修改,会发生什么?

结果有可能正常:但也有可能不正常;

比如 int i = i ++这行代码,很简单是不是,但是但多个线程访问的时候,你猜猜会发生什么?咱们代码来解释一切问题,请看

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
static int a = 0;

	public static void aomticITest() {
		int s = 10000;
		Thread[] ts = new Thread[s];

		for (int i = 0; i < s; i++) {
			Thread t = new Thread(() -> {
				a++;
			}, "----线程" + i);
			t.start();
			ts[i] = t;
		}
		
		for (Thread thread : ts) {
			try {
				thread.join();
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
		
		System.out.println(s+ "个线程后a的值:" +a);
	}

结果:

10000个线程后a的值:10000

10000个线程后a的值:9999

10000个线程后a的值:9997

这里运算了3个结果;

虽然加锁可以实现保证得到正确的结果,但这里研究Aomtic就不加锁了

所以这时候就有原子操作出现了

    • | int | incrementAndGet() 原子上增加一个当前值。 |
      | —– | ——————————————- |
      | | |
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
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
static int a = 0;
 private static AtomicInteger atomicA =new AtomicInteger();

public static void aomticITest() {
	int s = 10000;
	Thread[] ts = new Thread[s];
	Thread[] tss = new Thread[s];

	for (int i = 0; i < s; i++) {
		Thread t = new Thread(() -> {
			a++;
		}, "----线程" + i);
		t.start();
		ts[i] = t;
	}
	
	for (Thread thread : ts) {
		try {
			thread.join();
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
	}
	
	System.out.println(s+ "个线程后a的值:" +a);
	
	for (int i = 0; i < s; i++) {
		Thread t = new Thread(() -> {
			atomicA.incrementAndGet();
		}, "----线程" + i);
		t.start();
		tss[i] = t;
	}
	
	for (Thread thread : tss) {
		try {
			thread.join();
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
	}
	
	System.out.println(s+ "个线程后atomicA的值:" +atomicA);
}

结果:

10000个线程后a的值:9998
10000个线程后atomicA的值:10000

小唠嗑：

本章到这里就结束了，谢谢耐心看到这里的各位Boss,如果觉得有哪里说的不好的地方，还请高抬贵手多多原谅，不惜指教。

最后，谢谢！

---本文结束感谢您的阅读!---