一.LockSupport工具类
* 线程阻塞的工具类,所有的方法都是静态方法,可以让线程在任意位置阻塞。 阻塞之后也有唤醒的方法。
* park:停车。如果我们把Thread看成一辆车的话,park就是让车停下
* unpark:就是让车启动然后跑起来
* 这里的park和unpark其实实现了wait和notify的功能。
* 区别:
* 1.park不需要获取某个对象的锁(不释放锁),wait释放锁
* 2.因为中断park不会抛出InterruptedException异常,需要在park之后自行判断中断状态, 然后做额外的处理。unpark不会抛异常。
* 总结:
* 1.park和unpark可以实现wait和notify的功能,但是并不和wait和notify交叉使用。
* 2.park和unpark不会出现死锁。
* 3.blocker的作用看到阻塞对象的信息
public static final Object OBJ = new Object();
public void show() {
try {
super.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
public static void main(String[] args) throws InterruptedException {
Runnable runnable = () -> {
synchronized (OBJ) {
System.out.println("线程【" + Thread.currentThread().getName() + "】正在执行...");
// 阻塞
LockSupport.park("我被阻塞了...");
if(Thread.currentThread().isInterrupted()){
System.out.println("被中断了...");
}
System.out.println("继续执行...");
}
};
Thread t1 = new Thread(runnable,"线程一");
Thread t2 = new Thread(runnable,"线程二");
t1.start();
Thread.sleep(1000);
System.out.println(LockSupport.getBlocker(t1));
t2.start();
Thread.sleep(3000);
// 线程中断
t1.interrupt();
// 把t2唤醒
LockSupport.unpark(t2);
t1.join();
t2.join();
}
}
二..Lock锁
* Lock是一个接口
* 键盘输入
* 打印输出
* 极其耗资源IO操作。这两种在实际开发中绝对不允许使用!!!
public void show() {
Lock lock = new Lock() {
@Override
public void lock() {
}
@Override
public void lockInterruptibly() throws InterruptedException {
}
@Override
public boolean tryLock() {
return false;
}
@Override
public boolean tryLock(long time, TimeUnit unit) throws InterruptedException {
return false;
}
@Override
public void unlock() {
}
@Override
public Condition newCondition() {
return null;
}
};
// 加锁
lock.lock();
try {
// 正常处理业务逻辑
// 输入输出的操作IO操作
// 操作的是物理内存
// 多线程是内存操作
System.out.println();
}catch (Exception e){
// 当出现异常的解决方案
}finally { // 释放资源,关闭连接,关闭输入输出流
// 手动释放锁
lock.unlock();
}
}
public void info() {
Lock lock = new Lock() {
@Override
public void lock() {
}
@Override
public void lockInterruptibly() throws InterruptedException {
}
@Override
public boolean tryLock() {
return false;
}
@Override
public boolean tryLock(long time, TimeUnit unit) throws InterruptedException {
return false;
}
@Override
public void unlock() {
}
@Override
public Condition newCondition() {
return null;
}
};
// 如果拿到了锁
if(lock.tryLock()){
try {
// 正常处理业务逻辑
}catch (Exception e){
// 当出现异常的解决方案
}finally { // 释放资源,关闭连接,关闭输入输出流
// 手动释放锁
lock.unlock();
}
}else {
// 如果没有拿到锁,则直接做另外的事情
}
}
public static void main(String[] args) {
}
}
三. Lock接口的实现类ReentrantLock
* ReentrantLock,可重入锁。实现了Lock接口
* synchronized和Lock的区别:
* 1.Lock是一个接口,synchronized是一个关键字,是由底层(C)语言实现的。
* 2.synchronized发生异常时,会自动释放线程占用的锁不会发生死锁。
Lock发生异常,若没有主动释放,极有可能占用资源不放手,需要在finally中手动释放锁。
* 3.Lock可以让等待锁的线程响应中断,使用synchronized只会让等待的线程一直等待下去,不能响应中断
* 4.Lock可以提高多个线程进行读操作的效率。
class Ticket implements Runnable {
private static final ReentrantLock lock = new ReentrantLock();
private static Integer count = 100;
String name;
public Ticket(String name) {
this.name = name;
}
@Override
public void run() {
while(Ticket.count > 0){
lock.lock();
try {
try {
Thread.sleep(100);
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
if(count > 0){
System.out.println(name + "正在卖票,剩余:" + count + "张!");
count--;
// count = count - 1;
}
}finally {
lock.unlock();
}
}
// while(true) {
// try{
// lock.lock();
// if(count > 0){
// try {
// Thread.sleep(150);
// } catch (InterruptedException e) {
// throw new RuntimeException(e);
// }
// System.out.println(name + "正在卖票,剩余:" + count + "张!");
// count--;
// }else {
// System.out.println("票已售空!");
// break;
// }
// }finally {
// lock.unlock();
// }
// }
}
}
public class Ch03 {
public static void main(String[] args) {
Ticket t1 = new Ticket("窗口一");
Ticket t2 = new Ticket("窗口二");
Ticket t3 = new Ticket("窗口三");
new Thread(t1).start();
new Thread(t2).start();
new Thread(t3).start();
}
}
四.Lock以下功能是synchronized不具备的!
* ReentrantReadWriteLock:读写锁
* 对于一个应用而言,一般情况下读操作远远多于写的操作,如果仅仅是读的操作没有写的操作,
* 数据又是线程安全,读写锁给我们提供了一种锁,读的时候可以很多线程一起读,但是不能有线程写,
* 写是独占的,当有线程在执行写的操作,其他线程既不能读,也不能写。
*
* 在某些场景下能极大的提升效率!!!
private static ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
private static int count = 1;
public static void main(String[] args) {
Runnable read = () -> {
// 创建了一个读锁
ReentrantReadWriteLock.ReadLock readLock = lock.readLock();
readLock.lock();
try {
Thread.sleep(2000);
System.out.println("我在读数据:" + count);
} catch (InterruptedException e) {
e.printStackTrace();
}finally {
readLock.unlock();
}
};
Runnable write = () -> {
// 创建了一个写锁
ReentrantReadWriteLock.WriteLock writeLock = lock.writeLock();
writeLock.lock();
try {
Thread.sleep(2000);
System.out.println("我在写数据:" + count++);
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
writeLock.unlock();
}
};
for (int i = 0; i < 100; i++) {
Random random = new Random();
int flag = random.nextInt(100);
System.out.println("生成的随机整数:" + flag);
if(flag > 20){
new Thread(read).start();
}else {
new Thread(write).start();
}
}
}
}
五.lock锁的原理cas和aqs
* synchronized是由C语言实现的,只能作为关键字来使用
* java提供了一些并发的编程的包,底层的实现原理cas和aqs
* 并发编程三大特性:
* 1.原子性:原子操作可以是一个步骤,也可以是多个步骤,但是顺序不能乱,
* 也不可以被切割只执行其中的一部分,将整个操作视为一个整体。
* 原子性不仅仅是多行代码,也可能是多条指令。
* 2.可见性
* 3.有序性
* synchronized lock:可以保证原子性、可见性、有序性。
* CAS:compare and swap,比较并交换。JDK11改成了compare and set。
思路:就是给一个元素赋值的时候,先看看内存里的那个值到底变没变。
* AQS:抽象队列同步器,用来解决线程同步执行的问题。它是一个双向链表
java.util.concurrent.atomic下
* JUC并发编程包
* 1.原子类Atomic 基本类型
* AtomicInteger:整型原子类
* AtomicLong:长整型原子类
* AtomicBoolean:布尔型原子类
* 数组类型
* AtomicLongArray:长整型数组原子类
* AtomicIntegerArray:整型数组原子类
* AtomicReference<V>:引用数据类型原子类
public class Ch06 {
private static AtomicInteger adder = new AtomicInteger();
public static void main(String[] args) throws InterruptedException {
int a = 10;
for (int i = 0; i < 1000; i++) {
Thread thread = new Thread(() -> {
adder.getAndIncrement();
});
thread.start();
// 阻塞
thread.join();
}
System.out.println("a:" + a);
System.out.println("aaa:" + adder.get());
}
六.线程池
为什么要使用线程池
* (1)降低资源消耗。通过重复利用已创建的线程降低创建和销毁线程造成的资源消耗
* (2)提高响应速度。当任务到达时,任务可以不需要等到线程创建就能立即执行。
* (3)提过线程的可管理性。线程比较稀缺的资源,如果无限制的创建,不仅会消耗系统资源,
* 还会降低系统的稳定性,使用线程池可以进行统一的分配,调优和监控。
*
* JDK自带的四种线程池通过Executors提供的。
* 1.newCachedThreadPool:创建一个可缓存线程池,如果线程池长度超过处理需要,可以灵活回收空闲线程,
* 若无可回收,创建新线程。
* 2.newFixedThreadPool:创建一个定长的线程池,可以控制线程最大并发数,超出的线程会在队列中等待。
* 3.newScheduledThreadPool:创建一个定长的线程池,支持定时及周期性任务执行
* 4.newSingleThreadExecutor:创建一个单线程化的线程池,它只会用唯一的工作线程来执行任务,保证
* 所有的任务按照指定顺序执行
*
* 这四种线程池的初始化都调用了同一个构造器:
* ThreadPoolExecutor(int corePoolSize,
* int maximumPoolSize,
* long keepAliveTime,
* TimeUnit unit,
* BlockingQueue<Runnable> workQueue,
* ThreadFactory threadFactory,
* RejectedExecutionHandler handler)
* 参数的意义(重要):
* corePoolSize:线程池里线程的数量,核心线程池大小
* maximumPoolSize:指定了线程池里的最大线程数量
* keepAliveTime:当线程池线程数量大于corePoolSize,多出来的空闲线程,多长时间被销毁
* unit:时间单位
* workQueue:任务队列,用于存放提交但是尚未被执行的任务
* threadFactory:线程工厂,用来创建线程,线程工厂就是我们new线程的
* handler:拒绝策略,是将任务添加到线程池中时,线程池拒绝该任务多采取的相应的措施。
* 常见的工作队列
* ArrayBlockingQueue:基于数组的有界阻塞队列。FIFO。
* LinkedBlockingQueue:基于链表的有界阻塞队列。FIFO
* 线程池提供了四种拒绝策略:
* AbortPolicy:直接抛出异常,默认的策略。
* CallerRunPolicy:用调用者所在的线程来执行任务
* DiscardOldestPolicy:丢弃阻塞队列中最靠前的任务,并执行当前任务
* DiscardPolicy:直接丢弃任务
public class Ch01 {
public static void main(String[] args) {
ExecutorService cachedThreadPool = Executors.newCachedThreadPool();
Runnable taskOne = () -> {
System.out.println(Thread.currentThread().getName() + "taskOne...");
};
ExecutorService fixedThreadPool = Executors.newFixedThreadPool(10);
ExecutorService scheduledExecutorService = Executors.newScheduledThreadPool(10);
ExecutorService singleThreadExecutor = Executors.newSingleThreadExecutor();
for (int i = 0; i < 40; i++) {
fixedThreadPool.submit(taskOne);
}
}
}
自定义线程池
public class Ch02 {
private static final AtomicInteger poolNumber = new AtomicInteger(1);
private final ThreadGroup group;
private final AtomicInteger threadNumber = new AtomicInteger(1);
private final String namePrefix;
Ch02(String name){
SecurityManager s = System.getSecurityManager();
group = (s != null) ? s.getThreadGroup() : Thread.currentThread().getThreadGroup();
namePrefix = name + "-" + poolNumber.getAndIncrement() + "-thread-";
}
Ch02(){
this("default");
}
public Thread newThread(Runnable r){
// 就是在创建线程
Thread t = new Thread(group,r,namePrefix + threadNumber.getAndIncrement(),0);
if(t.isDaemon()){
t.setDaemon(false);
}
if(t.getPriority() != Thread.NORM_PRIORITY){
t.setPriority(Thread.NORM_PRIORITY);
}
return t;
}
public static void main(String[] args) {
Ch02 ch02 = new Ch02();
ch02.newThread(()->{
System.out.println("自定义线程池创建的线程...");
}).start();
}
}
创建线程的4种方式拒绝策略
* 2.线程同步(synchronized,ReentrantLock,ReentrantReadWriteLock)
* 3.线程之间的通信(wait,notify,notifyAll)
* 4.线程类的常用方法
* 指令重排,线程争抢,可见性,原子性,volatile关键字
多线程有点难 不会 💔💔💔💔