多线程2--相关理论知识-CSDN博客

如果很快别人就释放锁了，自旋是划算的，但是如果迟迟拿不到锁，一直自旋，并不划算。synchronized自旋不是无休止的自旋，自旋到一定程度后，就会再次升级成重量级锁（挂起等待锁），这次加锁是基于操作系统原生的API来进行加锁了，此时这个锁会影响到线程的调度。此时如果线程进行了重量级的加锁，并发生锁竞争，此时线程就会被放到阻塞队列中，暂时不参与CPU调度，知道锁被释放，这个线程才有机会获取到锁。（一旦线程被切出CPU，将会变成一个低效的事情）

2.锁消除

编译器智能的判断，看当前代码是否是真的要加锁，如果这个场景不需要加锁，程序员也加了，就自动把锁消除掉。

3.锁粗化

锁的粒度：synchronized包含的代码越多，粒度就越粗，包含的代码越少，粒度就越细。

通常情况下，认为锁的粒度细一点，比较好，加锁部分的代码是不能并发执行的。锁的粒度越细，能并发的代码越多，反之就越少。（类比筛子）

但在有的情况下，锁的粒度粗一些反而更好（两次加锁解锁之间间隔非常小，此时不如直接一次大锁搞定。

JUC

java.util.concurrent（并发）放了并发编程（多线程）相关的组件

各种集合类：scanner，random...

1.Callable接口

类似于Runnable一样，用来描述一个任务。

区别：Runnable描述的任务没有返回值，Callable描述的任务有返回值。

如果要使用一个线程单独计算出某个结果来，用Callable比较合适。

例：使用Callable来计算1+2+3+....+1000

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

public class ThreadDemo28 {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        //使用Callable来计算1+2+3+....+1000
        Callable<Integer> callable=new Callable<Integer>() {
            @Override
            public Integer call() throws Exception {
                //这里的call（）方法相当于Runnable中的run()方法
                //run()方法的返回值是void，call（）方法的返回值是泛型参数
                int sum=0;
                for (int i = 0; i <=1000; i++) {
                    sum+=i;
                }
                return sum;
            }
        };
       //  Thread t=new Thread(callable) 这里不能把callable直接传到Thread里面
        FutureTask<Integer> futureTask=new FutureTask<>(callable);
        Thread t =new Thread(futureTask);
        t.start();
        Integer result=futureTask.get();//get()获取结果
        System.out.println(result);
    }
}

2.ReentrantLock

可重入的，词根：entry 条目/入口

ReentrantLock是标准库提供的另一种锁，“可重入锁”。

synchronized是基于代码块的方式来加锁解锁的。

ReentrantLock更传统，使用了lock方法和unlock方法加锁解锁

这样的写法最大的问题就是unlock可能执行不到，这里使用try.....finally，unlock放在finally中，最后一定会执行unlock。

ReentrantLock的优势：

1.ReentrantLock提供了公平锁版本的实现。

可以根据构造方法的参数来确定使用公平锁还是非公平锁（true/false）

2.对于synchronized来说，提供的加锁方式就是“死等”，只要获取不到锁就一直阻塞等待，ReentrantLock提供了更加灵活的等待方式。

无参数版本，能加锁就加，加不上就放弃。

有参数版本，指定了超时时间，加不上锁就等待一会儿，如果时间到了也没有加上锁就放弃。

3.ReentrantLock提供了更强大的方便的一个等待通知机制

synchronized搭配的是wait notify.notify的时候是随机唤醒一个wait的线程

ReentrantLock搭配一个Condition类，进行唤醒的时候可以唤醒指定的线程。

注意：虽然ReentrantLock有一定的优势，但是在实际开发中大部分情况下还是使用的synchronized

import java.util.concurrent.locks.ReentrantLock;

public class ThreadDemo29 {
    public static void main(String[] args) {
        ReentrantLock reentrantLock=new ReentrantLock(true);
       boolean result=reentrantLock.tryLock();
       try{
           reentrantLock.tryLock();
       }finally {
           if(result) {
               reentrantLock.unlock();
           }
       }
    }
}

3.原子类

4.信号量semaphore

信号量本质上就是一个计数器，描述了可用资源的个数。

p操作：申请一个可用资源，计数器就要-1

V操作：释放一个可用操作，计数器就要+1

P操作如果要是计数器为0了，继续P操作，就会出现阻塞等待的情况。

import java.util.concurrent.Semaphore;

public class ThreadDemo30 {
    public static void main(String[] args) throws InterruptedException {
        Semaphore semaphore=new Semaphore(3);
        semaphore.acquire();
        System.out.println("执行一次P操作");
        semaphore.acquire();
        System.out.println("执行一次P操作");
        semaphore.acquire();
        System.out.println("执行一次P操作");
        semaphore.acquire();
        System.out.println("执行一次P操作");

        semaphore.release();
    }
}