一. Lock锁
1. ReentrantLock
ReentrantLock:重入锁 和synchronized作用一致
lock(); //上锁
unLock(); //开锁
- 用起来更加的自由和方便
- 关键字synchronized定义的代码块或者方法中如果出现异常，会自动释放锁
- Lock如果上锁后出现异常，不会释放锁
- 必须使用try-finally释放锁
package day24;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
public class Demo01 {
public static void main(String[] args) {
Runnable runnable = new Runnable() {
//买一把锁 一把重入锁
Lock lock = new ReentrantLock();
int count = 100;
@Override
public void run() {
while(true) {
try {
//上锁
lock.lock();
if(count<=0) {
break;
}
System.out.println(Thread.currentThread().getName()+"卖了第"+count+"票");
count--;
} finally {
//开锁
lock.unlock();
}
}
}
};
ExecutorService es = Executors.newCachedThreadPool();
for(int i=1; i<=3; i++) {
es.submit(runnable);
}
es.shutdown();
}
}
2. 读写锁
package day24;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.locks.ReentrantReadWriteLock;
import java.util.concurrent.locks.ReentrantReadWriteLock.ReadLock;
import java.util.concurrent.locks.ReentrantReadWriteLock.WriteLock;
public class Demo02 {
public static void main(String[] args) {
ReadAndWrite rw = new ReadAndWrite();
Runnable r1 = new Runnable() {
@Override
public void run() {
rw.write("dd");
}
};
Runnable r2 = new Runnable() {
@Override
public void run() {
String s = rw.read();
System.out.println(s);
}
};
ExecutorService es = Executors.newCachedThreadPool();
//三个线程写入
for(int i=0; i<3; i++) {
es.submit(r1);
}
//四个线程读入
for(int i=0; i<4; i++) {
es.submit(r2);
}
/*
* 读锁 和 写锁 的关系
*
* 写 写 互斥
* 写 读 互斥
*
* 读 写 互斥
* 读 读 不互斥
*
* 所有的目的：都是提高执行的效率
*/
}
}
class ReadAndWrite {
//重入读写锁
ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
//读锁
ReadLock readLock = lock.readLock();
//写锁
WriteLock writeLocl = lock.writeLock();
String str;
/*
* 如果使用synchronized关键对方法进行加锁
* 锁的对象，就是调用该方法的对象
*
* 如果一个线程获取了该对象锁，执行write方法
* 其他任何线程都不能获取到该对象锁，执行该对象中的方法
* public synchronized void write(String s) {}
*/
public void write(String s) {
readLock.lock();
str += s;
readLock.unlock();
}
public String read() {
writeLocl.lock();
//读取业务----
writeLocl.unlock();
return str;
}
}
3. 线程安全集合
-
CopyOnWriteArrayList
-
线程安全的ArrayList，加强版读写分离。
写有锁，读⽆锁，读写之间不阻塞，优于读写锁。
写⼊时，先copy⼀个容器副本、再添加新元素，最后替换引⽤。
使⽤⽅式与ArrayList⽆异。
-
Vector 线程安全的，底层是数组
-
//CopyOnWriteArrayList中写入，读取的方法 写有锁，读没有锁
public boolean add(E e) {
final ReentrantLock lock = this.lock;
//添加互斥锁
lock.lock();
try {
Object[] elements = getArray();
int len = elements.length;
Object[] newElements = Arrays.copyOf(elements, len + 1);
newElements[len] = e;
setArray(newElements);
return true;
} finally {
lock.unlock();
}
}
public E get(int index) {
return get(getArray(), index);
}
//Vector
public synchronized boolean add(E e) {
modCount++;
ensureCapacityHelper(elementCount + 1);
elementData[elementCount++] = e;
return true;
}
public synchronized E get(int index) {
if (index >= elementCount)
throw new ArrayIndexOutOfBoundsException(index);
return elementData(index);
}
- CopyOnWriteArraySet
- 线程安全的Set，底层使⽤CopyOnWriteArrayList实现。
- 写有锁，读无锁
- ConcurrentHashMap
- 线程安全的Map集合
- 初始容量默认为16段（Segment），使⽤分段锁设计
- 不对整个Map加锁，⽽是为每个Segment加锁
- 当多个对象存⼊同⼀个Segment时，才需要互斥。
- Hashtable
- 也是一个线程安全的Map集合
- 使用方法添加synchronized，实现的线程安全
- Map
- HashMap 线程不安全
- Hashtable 线程安全
- ConcurrentHashMap 线程安全
package com.qf;
import java.util.Hashtable;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.Vector;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.CopyOnWriteArrayList;
import java.util.concurrent.CopyOnWriteArraySet;
public class Demo03 {
public static void main(String[] args) {
//线程安全的List集合，读写分离 写有锁 读没有锁 相互不阻塞
List<String> list = new CopyOnWriteArrayList<String>();
//线程安全的List集合，方法加锁
List<String> list2 = new Vector<String>();
//线程安全的map集合 分段加锁（16个元素为一段）
Map<String,String> map = new ConcurrentHashMap<String, String>();
//线程安全的map集合 所有方法加锁
Map<String,String> map2 = new Hashtable<String, String>();
//线程安全的set集合 底层是CopyOnWriteArrayList
Set<String> set = new CopyOnWriteArraySet<String>();
}
}
4. 队列
Collection的⼦接⼝，表示队列FIFO（First In First Out）。
public interface Queue<E> extends Collection<E> {
boolean add(E e);
boolean offer(E e);
E remove();
E poll();
E peek();
}
package day24;
import java.util.LinkedList;
import java.util.Queue;
public class Demo04 {
public static void main(String[] args) {
/*
* 队列: 遵循先进先出
* 选择类名或者接口名，点击Ctrl+t 可以该类及接口的继承和实现情况
*
*/
Queue<String> queue = new LinkedList<String>();
//添加元素
queue.offer("熊大");
queue.offer("熊二");
queue.offer("熊三");
queue.offer("熊四");
int size = queue.size();
System.out.println(size);
//获取元素 并删除
for(int i=0; i<size; i++) {
String value = queue.poll();
System.out.println(value + "---队列中还剩"+queue.size()+"个元素");
}
}
}
