AG 百家乐最新官网《 787977.tv 蝙蝠 14735340 》java 并发编程 (2)：Java 多线程 - java.util.concurrent 高级工具

高级多线程控制类

Java1.5 提供了一个非常高效实用的多线程包:java.util.concurrent, 提供了大量高级工具，可以帮助开发者编写高效、易维护、结构清晰的 Java 多线程程序。

ThreadLocal 类

ThreadLocal 类 用来保存线程的独立变量。对一个线程类（继承自 Thread)

当使用 ThreadLocal 维护变量时，ThreadLocal 为每个使用该变量的线程提供独立的变量副本，所以每一个线程都可以独立地改变自己的副本，而不会影响其它线程所对应的副本。常用于用户登录控制，如记录 session 信息。

实现：每个 Thread 都持有一个 TreadLocalMap 类型的变量（该类是一个轻量级的 Map，功能与 map 一样，区别是桶里放的是 entry 而不是 entry 的链表。功能还是一个 map。）以本身为 key，以目标为 value。

主要方法是 get () 和 set (T a)，set 之后在 map 里维护一个 threadLocal -> a，get 时将 a 返回。ThreadLocal 是一个特殊的容器。

原子类（AtomicInteger、AtomicBoolean……）

如果使用 atomic wrapper class 如 atomicInteger，或者使用自己保证原子的操作，则等同于 synchronized

AtomicInteger.compareAndSet (int expect,int update)// 返回值为 boolean

AtomicReference

对于 AtomicReference 来讲，也许对象会出现，属性丢失的情况，即 oldObject == current，但是 oldObject.getPropertyA != current.getPropertyA。

这时候，AtomicStampedReference 就派上用场了。这也是一个很常用的思路，即加上版本号

Lock 类　

lock: 在 java.util.concurrent 包内。共有三个实现：

1. ReentrantLock
2. ReentrantReadWriteLock.ReadLock
3. ReentrantReadWriteLock.WriteLock

主要目的是和 synchronized 一样， 两者都是为了解决同步问题，处理资源争端而产生的技术。功能类似但有一些区别。

区别如下：

1. lock 更灵活，可以自由定义多把锁的枷锁解锁顺序（synchronized 要按照先加的后解顺序）
2. 提供多种加锁方案，lock 阻塞式，trylock 无阻塞式，lockInterruptily 可打断式， 还有 trylock 的带超时时间版本。
3. 本质上和监视器锁（即 synchronized 是一样的）
4. 能力越大，责任越大，必须控制好加锁和解锁，否则会导致灾难。
5. 和 Condition 类的结合。
6. 性能更高，synchronized 和 Lock 性能对比，如下图：

java.util.concurrent lock 与 synchronized 性能对比

ReentrantLock 的使用

可重入的意义在于持有锁的线程可以继续持有，并且要释放对等的次数后才真正释放该锁。

private java.util.concurrent.locks.Lock lock = new ReentrantLock();
public void method() {	
	try {		
		lock.lock();		//获取到锁lock，同步块
	} finally {		
		lock.unlock();//释放锁lock
	}
}

• ReentrantLock 比 synchronized 功能更强大，主要体现：
• ReentrantLock 具有公平策略的选择。
• ReentrantLock 可以在获取锁的时候，可有条件性地获取，可以设置等待时间，很有效地避免死锁。
• 如 tryLock () 和 tryLock (long timeout, TimeUnit unit)
• ReentrantLock 可以获取锁的各种信息，用于监控锁的各种状态。
• ReentrantLock 可以灵活实现多路通知，即 Condition 的运用。

公平锁与非公平锁

ReentrantLock 默认是非公平锁，允许线程 “抢占插队” 获取锁。公平锁则是线程依照请求的顺序获取锁，近似 FIFO 的策略方式。

锁的使用

1. lock () 阻塞式地获取锁，只有在获取到锁后才处理 interrupt 信息
2. lockInterruptibly () 阻塞式地获取锁，立即处理 interrupt 信息，并抛出异常
3. tryLock () 尝试获取锁，不管成功失败，都立即返回 true、false，注意的是即使已将此锁设置为使用公平排序策略，tryLock () 仍然可以打开公平性去插队抢占。如果希望遵守此锁的公平设置，则使用 tryLock (0, TimeUnit.SECONDS)，它几乎是等效的 (也检测中断)。
4. tryLock (long timeout, TimeUnit unit) 在 timeout 时间内阻塞式地获取锁，成功返回 true，超时返回 false，同时立即处理 interrupt 信息，并抛出异常。

如果想使用一个允许闯入公平锁的定时 tryLock，那么可以将定时形式和不定时形式组合在一起：

if (lock.tryLock() || lock.tryLock(timeout, unit) ) { ... }

private java.util.concurrent.locks.ReentrantLock lock = new ReentrantLock();
public void testMethod() {	
	try {		
		if (lock.tryLock(1, TimeUnit.SECONDS)) {
			//获取到锁lock，同步块
		} else {		
			//没有获取到锁lock
		}
	} catch (InterruptedException e) {
		e.printStackTrace();
	} finally {
		if (lock.isHeldByCurrentThread())
		//如果当前线程持有锁lock，则释放锁lock
			lock.unlock();
	}
}

条件 Condition 的使用

条件 Condition 可以由锁 lock 来创建，实现多路通知的机制。

具有 await、signal、signalAll 的方法，与 wait/notify 类似，需要在获取锁后方能调用。

private final java.util.concurrent.locks.Lock lock = new ReentrantLock();
private final java.util.concurrent.locks.Condition condition = lock.newCondition();
public void await() {	
	try {		
		lock.lock();		//获取到锁lock
		condition.await();//等待condition通信信号，释放condition锁
		//接到condition通信
	} catch (InterruptedException e) {
		e.printStackTrace();
	} finally {
		lock.unlock();//释放对象锁lock
	}
}

ReentrantReadWriteLock 的使用

ReentrantReadWriteLock 是对 ReentrantLock 更进一步的扩展，实现了读锁 readLock ()(共享锁) 和写锁 writeLock ()(独占锁)，实现读写分离。读和读之间不会互斥，读和写、写和读、写和写之间才会互斥，提升了读写的性能。

读锁示例：

private final java.util.concurrent.locks.ReadWriteLock lock = new ReentrantReadWriteLock();
public void method() {	
	try {		
		lock.readLock().lock();//获取到读锁readLock，同步块
	} finally {		
		lock.readLock().unlock();//释放读锁readLock
	}
}

写锁示例：

private final java.util.concurrent.locks.ReadWriteLock lock = new ReentrantReadWriteLock();
public void method() {	
	try {		
		lock.writeLock().lock(); //获取到写锁writeLock，同步块
	} finally {
		lock.writeLock().unlock(); //释放写锁writeLock
	}
}

容器类

同步容器与异步容器概览

同步容器

包括两部分：

• 一个是早期 JDK 的 Vector、Hashtable；
• 一个是它们的同系容器，JDK1.2 加入的同步包装类，使用 Collections.synchronizedXxx 工厂方法创建。

Map<String, Integer> hashmapSync = Collections.synchronizedMap(new HashMap<>());

同步容器都是线程安全的，一次只有一个线程访问容器的状态。

但在某些场景下可能需要加锁来保护复合操作。

复合类操作如：新增、删除、迭代、跳转以及条件运算。

这些复合操作在多线程并发的修改容器时，可能会表现出意外的行为，

最经典的便是 ConcurrentModificationException，

原因是当容器迭代的过程中，被并发的修改了内容，这是由于早期迭代器设计的时候并没有考虑并发修改的问题。

其底层的机制无非就是用传统的 synchronized 关键字对每个公用的方法都进行同步，使得每次只能有一个线程访问容器的状态。这很明显不满足我们今天互联网时代高并发的需求，在保证线程安全的同时，也必须有足够好的性能。

并发容器

与 Collections.synchronizedXxx () 同步容器等相比，util.concurrent 中引入的并发容器主要解决了两个问题：

1. 根据具体场景进行设计，尽量避免 synchronized，提供并发性。
2. 定义了一些并发安全的复合操作，并且保证并发环境下的迭代操作不会出错。

util.concurrent 中容器在迭代时，可以不封装在 synchronized 中，可以保证不抛异常，但是未必每次看到的都是 "最新的、当前的" 数据。

Map<String, Integer> concurrentHashMap = new ConcurrentHashMap<>();

ConcurrentHashMap 替代同步的 Map 即 (Collections.synchronized (new HashMap ()))。

众所周知，HashMap 是根据散列值分段存储的，同步 Map 在同步的时候会锁住整个 Map，而 ConcurrentHashMap 在设计存储的时候引入了段落 Segment 定义，同步的时候只需要锁住根据散列值锁住了散列值所在的段落即可，大幅度提升了性能。ConcurrentHashMap 也增加了对常用复合操作的支持，比如 "若没有则添加"：putIfAbsent ()，替换：replace ()。这 2 个操作都是原子操作。注意的是 ConcurrentHashMap 弱化了 size () 和 isEmpty () 方法，并发情况尽量少用，避免导致可能的加锁 (当然也可能不加锁获得值，如果 map 数量没有变化的话)。 CopyOnWriteArrayList 和 CopyOnWriteArraySet 分别代替 List 和 Set，主要是在遍历操作为主的情况下来代替同步的 List 和同步的 Set，这也就是上面所述的思路：迭代过程要保证不出错，除了加锁，另外一种方法就是 "克隆" 容器对象。--- 缺点也明显，占有内存，且数据最终一致，但数据实时不一定一致，一般用于读多写少的并发场景。

• ConcurrentSkipListMap 可以在高效并发中替代 SoredMap (例如用 Collections.synchronzedMap 包装的 TreeMap)。
• ConcurrentSkipListSet 可以在高效并发中替代 SoredSet (例如用 Collections.synchronzedSet 包装的 TreeMap)。
• ConcurrentLinkedQuerue 是一个先进先出的队列。它是非阻塞队列。注意尽量用 isEmpty，而不是 size ();

CountDownLatch 闭锁的使用

管理类

管理类的概念比较泛，用于管理线程，本身不是多线程的，但提供了一些机制来利用上述的工具做一些封装。

了解到的值得一提的管理类：ThreadPoolExecutor 和 JMX 框架下的系统级管理类 ThreadMXBean

ThreadPoolExecutor

如果不了解这个类，应该了解前面提到的 ExecutorService，开一个自己的线程池非常方便：

ExecutorService e = Executors.newCachedThreadPool();
    ExecutorService e = Executors.newSingleThreadExecutor();
    ExecutorService e = Executors.newFixedThreadPool(3);
    // 第一种是可变大小线程池，按照任务数来分配线程，
    // 第二种是单线程池，相当于FixedThreadPool(1)
    // 第三种是固定大小线程池。
    // 然后运行
    e.execute(new MyRunnableImpl());

该类内部是通过 ThreadPoolExecutor 实现的，掌握该类有助于理解线程池的管理，本质上，他们都是 ThreadPoolExecutor 类的各种实现版本。

参考文章：

Java 多线程并发编程一览笔录 https://www.cnblogs.com/yw0219/p/10597041.html

Java 中的多线程你只要看这一篇就够了 https://juejin.im/entry/57339fe82e958a0066bf284f

Android java.util.concurrent.TimeUnit将毫秒转换为分钟

有没有办法使用java.util.concurrent.TimeUnit将毫秒转换为分钟？

This answer似乎建议您可以使用TimeUnit.MILLISECONDS.toMinutes()方法,并且文档建议您可以将TimeUnit.MILLISECONDS.convert()方法与TimeUnit.MINUTES一起使用 – 问题在于TimeUnit.MINUTES或TimeUnit都没有.MILLISECONDS.toMinutes()似乎确实存在.

我在这里错过了什么吗？

解决方法:

我相信TimeUnit可能会在1.6：1.6 docs,1.5 docs中添加分钟

Android-Studio-2.3错误：java.util.concurrent.ExecutionException：java.lang.RuntimeException：AAPT进程尚未准备好接收命令

sudo apt-get install lib32stdc++6
sudo apt-get install lib32z1

我们今天的关于【java.util.concurrent.Executors】和java.util.propertypermission的分享就到这里，谢谢您的阅读，如果想了解更多关于'java.lang.NoClassDefFoundError 由 java.lang.ClassNotFoundException 引起的 Ljava/util/Base64 解析失败 未找到类“java.util.Base64”、AG 百家乐最新官网《 787977.tv 蝙蝠 14735340 》java 并发编程 (2)：Java 多线程 - java.util.concurrent 高级工具、Android java.util.concurrent.TimeUnit将毫秒转换为分钟、Android-Studio-2.3错误：java.util.concurrent.ExecutionException：java.lang.RuntimeException：AAPT进程尚未准备好接收命令的相关信息，可以在本站进行搜索。