多线程进阶（下）

最新推荐文章于 2024-07-17 17:53:42 发布

键舞者

最新推荐文章于 2024-07-17 17:53:42 发布

阅读量171

点赞数

分类专栏： se 文章标签：大数据

本文链接：https://blog.csdn.net/qq_52655865/article/details/125847311

版权

se 专栏收录该内容

15 篇文章 7 订阅

订阅专栏

1，lock对象锁：java.util.concurrent.lock也可以加锁

juc.CountDownLatch：允许多个线程在某一线程中执行一组操作；大号的join方法

await（），计数器为0，则调用该线程的方法开始执行。

juc.CyclicBarrier——循环栅栏

juc.Exchanger——交换器

线程池的关闭

pool.shutdown()：关闭当前的所有的空闲线程，工作的线程，run方法执行结束自动关闭

pool.shutdownNow()：无论线程是否再工作，关闭所有的线程，关闭线程池

public class CloseThreadPool {
    public static void main(String[] args) {
        /*
        创建一个线程池
        核心线程数：3
        最大线程数：6
        临时线程空闲3s后被关闭
        阻塞队列：无界
        线程拒绝策略：抛出异常
         */

        ExecutorService pool = new ThreadPoolExecutor(3,6,
                3,TimeUnit.SECONDS,new LinkedBlockingQueue<>(),new ThreadPoolExecutor.AbortPolicy());
        for (int i = 0; i < 10; i++) {
            pool.submit(new Runnable() {
                @Override
                public void run() {
                    System.out.println(Thread.currentThread().getName() + "正在工作。。。");
                    try {
                        Thread.sleep(2000);
                    } catch (InterruptedException e) {
                        throw new RuntimeException(e);
                    }
                }
            });
        }
        try {
            Thread.sleep(6000);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
        //pool.shutdown();关闭空闲线程，工作线程run方法执行结束，自动关闭
        pool.shutdownNow();//立即关闭所有的线程
        System.out.println("线程池被关闭");
    }
}

CAS（乐观锁的一种实现）

：compare and swap ：比较交换，不会真正阻塞线程，不断尝试更新

CAS的应用：

1，使用CAS的原子类：

java.util.concurrent.atomic（juc）包中的所有类都是线程安全的原子类。

CAS机制实现的无锁的线程安全

public class CAS实现无所的线程机制 {
    class Counter{
        AtomicInteger count = new AtomicInteger();
        void increase(){
            count.incrementAndGet();//count对象的值先++，再获取值
        }
    }

    public static void main(String[] args) throws InterruptedException {
        Counter counter = new CAS实现无所的线程机制().new Counter();
        Thread t1 = new Thread(() -> {
            for (int i = 0; i < 50000; i++) {
                counter.increase();
            }
        });
        Thread t2 = new Thread(() -> {
            for (int i = 0; i < 50000; i++) {
                counter.increase();
            }
        });
        t1.start();
        t2.start();
        t1.join();
        t2.join();
        System.out.println(counter.count.get());
    }
}

无锁状态下保证了count++操作的原子性

2，CAS实现自旋锁

自旋锁：获取锁失败的线程，不阻塞，在cpu上空运行，一旦锁被释放，自旋锁的线程就很容易获取线程。

自旋锁在获取锁失败，就线程空运行，一直访问对象锁Compare，一旦检测到对象锁被释放，就立即站有锁（and swap）

CAS的存在的问题

CAS引发的ABA问题

加入版本号解决ABA问题：

synchronized锁升级的流程：

锁的升级有JVM实现

java创建线程的四种方式：

1，继承Thread类

2，实现Runnable接口 —> 不带返回值，覆写run方法

3，实现Callable接口，—>带返回值，覆写call方法（线程的核心工作方法）

4，线程池

Callable接口创建线程：

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.Future;
import java.util.concurrent.FutureTask;

public class CallableTeat {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        Callable<Integer> callable = new Callable<Integer>() {//匿名对象覆写call方法
            @Override
            public Integer call() throws Exception {
                int sum = 0;
                for (int i = 0; i < 1000; i++) {
                    sum++;
                }
                return sum;
            }
        };
        //callable接口中call方法的返回值，必须将callable接口的对象，
        // 传入到FutureTask类中，然后将通过FutureTask.get()接收返回值
        FutureTask<Integer> futureTask = new FutureTask<>(callable);
        //再将
        Thread t = new Thread(futureTask);
        t.start();
        //调用futrueTask的get方法获取返回值，如果线程callable没有执行完成，主线程就会进入阻塞状态
        Integer integer = futureTask.get();
        System.out.println(integer);
    }
}

调用FutureTask对象的get方法，就会将调用的线程进入阻塞状态，知道call方法执行结束。

juc包下的常用类

1，lock对象锁：java.util.concurrent.lock也可以加锁

在java中除了有synchronized锁（需要JVM借助OS的mutex系统原语实现），还有juc.lock锁（不需要借助OS，java语言自己实现的互斥机制（cpu层次））。

lock方法和unlock方法

public class lockTeat {
    public static void main(String[] args) {
        Lock lock = new ReentrantLock();
        Thread t1 = new Thread(() ->{
            lock.lock();
            try {
                System.out.println(Thread.currentThread().getName()+"被锁住了，无法帮你");
                Thread.sleep(6000);
            }catch (Exception e){
                e.printStackTrace();
            }finally {
                lock.unlock();
            }
        },"小札");
        Thread t2 = new Thread(() ->{
            boolean isLock = false;
            try {
                lock.lock();
                System.out.println(Thread.currentThread().getName()+"在等待帮助。。。");
            }catch (Exception e){
                e.printStackTrace();
            }finally {
                lock.unlock();
            }
        },"大札");
        t1.start();
        t2.start();
    }
}

tryLock和unlock方法

package 多线程.复习.lock锁;

import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class lockTeat {
    public static void main(String[] args) {
        Lock lock = new ReentrantLock();
        Thread t1 = new Thread(() ->{
            lock.lock();
            try {
                System.out.println(Thread.currentThread().getName()+"被锁住了，无法帮你");
                Thread.sleep(6000);
            }catch (Exception e){
                e.printStackTrace();
            }finally {
                lock.unlock();
            }
            System.out.println(Thread.currentThread().getName()+"的锁被解开了");
        },"小札");
        Thread t2 = new Thread(() ->{
            boolean isLock = false;
            try {
                lock.tryLock(2, TimeUnit.SECONDS);
                System.out.println("我等你两秒你还不来帮我，你滚，我i不要了");
            }catch (Exception e){
                e.printStackTrace();
            }finally {
                if(isLock)
                lock.unlock();
            }

        },"大札");
        t1.start();
        t2.start();
    }
}

synchronized和lock的区别

1，synchronized是Java中的关键字，由JVM实现，需要依赖OS的mutex互斥实现，Lock是java标准类库中的接口，是java本身实现的，不需要依赖操作系统。

2，synchronized是隐式加锁和解锁，lock是显示的枷锁与解锁。lock常见的使用子类为ReentrantLock，可重入锁

3，synchronized关键字，在获取锁失败时，死等解锁，lock锁可以在获取锁时，使用tyrLock在超过固定时间后没有获取到锁，就会开始执行其他代码，不hi死等；

4，synchronized是非公平锁，ReentrantLock是非公平锁，但是可以在构造方法中，传入参数true，嫁给你lock锁初始化为公平锁

5，synchronized本身不支持读写锁，但是在lock体系中，ReentrantReadWriteLock子类支持读写锁。

死锁：两个进程互相占用对方需要的资源，两者都不释放当前的资源，就会死锁

死锁产生的四个必要条件：

1，资源互斥访问

2，不可抢占

3，请求和保持

4，循环等待

当以上三个条件都成立时，就会出现死锁，任意破坏任何一个条件，死锁都解除。

前三个条件是锁的特性，不可破坏，所以破坏循环等待，避免线程之间请求成环，就可以解决死锁。