多线程-进阶2

news2024/9/20 9:41:31

博主主页: 码农派大星.

数据结构专栏:Java数据结构

数据库专栏:MySQL数据库

JavaEE专栏:JavaEE

关注博主带你了解更多数据结构知识

1.CAS

1.1CAS全称:Compare and swap

比较内存和cpu寄存器中的内容,如果发现相同,就进行交换(交换的是内存和另一个寄存器的内容)

一个内存的数据和两个寄存器中的数据进行操作(寄存器1和寄存器2)

此处的"交换"实际上就是赋值

比较内存和寄存器1中的值,是否相等,如果不等,就无事发生,如果相等,就交换内存和寄存器2的值(此处只关心内存交换后的内容,不关心寄存器2交换后的内容)

因此CAS就能编写多线程代码,"无锁化编程"

CAS具体使用场景

1)基于CAS实现原子类都是线程安全

import java.util.concurrent.atomic.AtomicInteger;
public class Main5 {
private static AtomicInteger count = new AtomicInteger(0);
public static void main(String[] args) throws InterruptedException {
        Thread t1 = new Thread(()->{
            for (int i = 0; i <50000 ; i++) {
             count.getAndIncrement();//count++
//           count.incrementAndGet();//++count
//           count.getAndDecrement();//count--
//           count.decrementAndGet();//--count
     //      count.getAndAdd(10);//count+= 10
            }
        });
        Thread t2 = new Thread(()->{
            for (int i = 0; i <50000 ; i++) {
                count.getAndIncrement();//count++
              /*  count.incrementAndGet();//++count
                count.getAndDecrement();//count--
                count.decrementAndGet();//--count*/
            }
        });
        t1.start();
        t2.start();
        t1.join();
        t1.join();
        System.out.println(count.get());
    }
}

2.Callable接口

Callable 接口也是创建线程的一种方式。相当于把线性封装了一个返回值。

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

public class Main {

    public static void main(String[] args) throws ExecutionException, InterruptedException {
        Callable<Integer> callable = new Callable<Integer>() {
            @Override
            public Integer call() throws Exception {
                int sum = 0;
                for (int i = 0; i < 1000; i++) {
                    sum += i;

                }
                return sum;
            }
        };
        FutureTask<Integer> futureTask = new FutureTask<>(callable);
        Thread t = new Thread(futureTask);
        t.start();
        System.out.println(futureTask.get());


    }
}

3.创建线程的方式:

1.直接继承Thead类

2.使用Runnable

3.使用Callable

4.使用lambda

5.使用线程池

4.ReentrantLock

4.1synchroniazed与ReentrantLock区别

1)大多是情况下使用synchronized,属于关键字(底层是通过JVM的c++代码实现的)

ReentrantLock则是标准库提供的类,通过Java代码实现的

2)synchronized通过代码块控制加锁解锁,ReentrantLock通过调用lock unlock方式来完成 unlock可能会遗漏

3)ReentrantLock 提供了tryLock这样的加锁风格

前面介绍的加锁,都是发现锁被别人占用了,就阻塞等待

tryLock在加锁失败的时候,不会阻塞,而是返回,通过返回值来反馈是加锁成功还是失败

4)1Reentrantlock提供了公平锁的实现

默认是非公平的,可以在构造方法中,传入参数,设定成公平的

5)Reentrantlock还提供了功能更强的功能"等待通知机制"

基于Condition类,能力要比wait notify更强一些.

import java.util.concurrent.locks.ReentrantLock;

public class Main2 {
    public static int count = 0;
    public static void main(String[] args) throws InterruptedException {
        ReentrantLock locker = new ReentrantLock();
        Thread t1 = new Thread(()->{
            for (int i = 0; i < 50000; i++) {
                locker.lock();
                count++;
                locker.unlock();
            }
        });
        Thread t2 = new Thread(()->{
            for (int i = 0; i <50000 ; i++) {
                locker.lock();
                count++;
                locker.unlock();
            }
        });
        t1.start();
        t2.start();
        t1.join();
        t2.join();
        System.out.println(count);
    }



}

5.信号量Semaphore

import java.util.concurrent.Semaphore;

public class Main3 {
    public static void main(String[] args) throws InterruptedException {
        Semaphore semaphore =new Semaphore(3);//可硬资源数,计数器初始值

        semaphore.acquire();
        System.out.println("申请一个资源");
        semaphore.acquire();
        System.out.println("申请一个资源");
        semaphore.acquire();
        System.out.println("申请一个资源");
        semaphore.release();
        System.out.println("释放一个资源");
        semaphore.acquire();
        System.out.println("申请一个资源");


    }


}

6.CountDownLatch

import java.util.concurrent.CountDownLatch;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class Main4 {
    public static void main(String[] args) throws InterruptedException {
        ExecutorService executorService = Executors.newFixedThreadPool(5);
        //构造方法的数字,就是拆分出来的任务个数
        CountDownLatch countDownLatch =new CountDownLatch(20);

        for(int i = 0 ; i < 20;i++){
            int id = i;
            executorService.submit(()->{
                System.out.println("下载任务"+id+"开始执行");
                try {
                    Thread.sleep(3000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }

                System.out.println("下载任务"+id+"结束任务");
                //完毕!!
                countDownLatch.countDown();
            });
        }

            //当countDownLatch收到20个"完成",所有的任务就完成了
 //await= allwait
            countDownLatch.await();

    }



}

借助CountDownLatch就能衡量出当前任务是否整体执行结束