文章目录
- ----------------------------------线程的锁-----------------------------------------
- 1.Synchroized
- 2. ReetrantLock
- 3. 线程池
- 4.另一种锁：LockSupport
- 5. 乐观锁（补充）
- 6. JMM
- 7.轻量级锁 volatile
- 8.volatile和Synchronized的比较
- ----------------------------------线程通信方式-----------------------------------------
- 1.CountDownLatch(CDL)
- 2.CyclicBarrier
- 3.Semaphore
- 4.生产者、消费者
- ------------------------------线程：ThreadLocal----------------------------------
- 1.7的ThreadLocal
- 1.8的ThreadLocal
- 3.内存泄漏
----------------------------------线程的锁-----------------------------------------
1.Synchroized
前提：八股看了一遍又一遍，每次看这个Synchroized都有点不同，这次把整体总结一下
- 用处：同步代码块、同步方法
- 对于非静态的一般上锁就是针对当前的对象实例；而对于静态的则针对的当前类的所有对象，因为对于类的信息我们是存在方法区的，JVM中只有一份。
- 对象：一个对象在存储中，包含了对象头、实例数据、对其数据。而对象头又包含了MarkWord、类指针（指向类的信息），而对于锁这一部分，其实主要是MarWord这一部分：分代年龄（GC）、hashCode（HashMap）、标记位（这一部分标记了无锁、偏向锁、轻量级锁、重量级锁）
- 简单说一下：无锁、偏向锁（只有一个线程）、轻量级锁（多个线程顺序执行）、重量级锁（抢锁），当然还有自旋锁，自适应自旋锁等。
所以对于锁来说，其实就是对象监视器来针对当前对象的对象头的标志位的一个抢占（对于类的话，应该是类对象吧，只有一个），主要以对象头标志抢占为主：
- 拥有对象监视器（锁）的线程
- 其他线程来的时候会进行cas抢锁，抢不到进到等待队列中（竞争队列、候选队列），因为可能同时有大量线程在等待队列中，所以我们将一部分线程拿到候选队列，作为下一次的锁的优先竞争者
- Ondesk，下一次获取锁的线程，在当前线程释放锁之后，会在候选队列的一个线程中唤醒一个指定到Ondesk，然后再开始竞争，这里的竞争主要是Ondesk线程和此时正在cas的线程，所以这是竞争切换，明显不公平
- 还有一个阻塞队列，是调用wait函数的线程，会把当前对象的锁释放，然后把当前线程放到阻塞队列中，只有其他线程进行notify唤醒，才可以重新进入等待队列的候选队列
注：
三种队列：等待队列（竞争队列+候选队列）、阻塞队列、运行的线程、下次竞争的线程
2. ReetrantLock
顺便把它讲了吧，这是JDK实现的，而上面的是内置的；并且ReentrantLock需要手动释放锁，出现异常可能会产生死锁，而Synchronized会自动释放；两者都是非公平锁+可重入锁，但是前者（lock）可以实现公平锁，并且可中断。
- 内部最重要的可以说是AQS-队列抽象同步器
- 继承它的内部类分别实现了公平锁、和非公平锁
- 思想：一个是state状态 = c、一个是线程队列
- 1.公平锁
- 刚开始不会直接CAS抢锁
- if c == 0
- 判断队列是否为空，为空则cas抢锁，c = 1；否则加入队列
- else 可重入（一般判断线程名是否相等）
- 加入队列
- 2.非公平锁
- 直接cas抢锁（明显不公平）
- if c == 0
- cas 抢锁成功 c ==1；失败加入队列
- else 可重入
- 加入队列
注：可以看到其实和synchroized一样都是刚开始进行cas抢锁，明显不公平。
3. 线程池
继续--------
为什么需要？
1.可以进行重用，来任务的时候快速的启动，避免线程的销毁
2.线程池统一管理、统一分配
参数：
核心线程数量、最大线程数量、存活时间、单位、阻塞队列、拒绝策略、线程工厂
常见的几种线程池：
- newFixedPoolThread（n,n,0,s,LinkedBlockingQuene）
- newSinglePoolThread（1，1，0，s,LinkedBlockedQueue）
- newCachePoolThread(0,Max_Value,60,s,SynchronousQuene)
- newSchedulePoolThread–定时执行
ScheduledExecutorService scheduledThreadPool = Executors.newScheduledThreadPool(5); scheduledThreadPool.schedule(new Runnable() { @Override public void run() { System.out.println("delay 3 seconds"); } }, 3, TimeUnit.SECONDS);
工作原理：
对于新来的任务
- 创建核心线程
- 核心线程数量达到最大，进入队列
- 队列满了，创建非核心线程
- 都满了，则拒绝策略
- 时间到了，非核心线程死亡
拒绝策略：
- 直接丢弃
- 丢弃 + 并抛出异常
- 抛弃队列队首，加入当前线程
- 调用当前任务的线程代为执行
阻塞队列：
- LinkedBlockingQueue 无穷大
- SynchronousQueue 不存储任何线程
- 还有其他的就不一一列举了
4.另一种锁：LockSupport
public class LockSupportTest {
public static void main(String[] args) {
Thread parkThread = new Thread(new ParkThread());
parkThread.start();
System.out.println("开始线程唤醒");
LockSupport.unpark(parkThread);
System.out.println("结束线程唤醒");
}
static class ParkThread implements Runnable{
@Override
public void run() {
System.out.println("开始线程阻塞");
LockSupport.park();
System.out.println("结束线程阻塞");
}
}
}
- 内部解析：
- 维护一个类似于信号量的值Counter = 0 /1
- park()方法，进行阻塞
- unpark(线程名)方法，进行唤醒
- 有个问题？
- 1.如果先唤醒，在阻塞怎么办？
- 答：不会受影响
- 2.如果唤醒两次，阻塞两次会怎么办？？
- 答：会阻塞，因为唤醒两次Counter的值也就是1，而阻塞第二次就会判断为0，而真正的阻塞。
5. 乐观锁（补充）
- 1.cas实现
- 主要是判断两次的值是否变化，while循环一直尝试（自旋锁）
- 三个参数：（期望的值，当前的值，修改的值）
- AtomicInteger：原子类就是这个原理，但是其内部其实是调用unsafe类，这个类在底层是直接获取变量的地址，通过比较地址的值来进行比较。
- 2.版本号实现
- 在cas的基础上加了version
- 主要防止ABA问题，每次操作都会在version.+1，只有同时满足version相等，并且cas为true，才有意义。
- java中主要实现的是：AtomicStampReference
6. JMM
- 非常类似于cpu + 内存 + 高度cache
- JMM : cpu + 线程cache + 内存（jvm的内存）
- java内存模型在实现上有着“happen-before”的规则：
- 1.单线程下，前面的代码>后面的代码
- 2.释放锁>获取锁
- 3.一个线程的start方法>后续操作
- 4.join的线程>被join的线程
- 5.volatile的写>读
- 6.传递性
- 三种特性：
- 可见性、有序性、原子性
7.轻量级锁 volatile
-
保证了可见性 + 有序性
-
可见性：
对于volatile修饰的变量，当我们使用的时候，会优先从内存读取，这就保证了缓存失效的原则；即读和取都要从内存中，让不是缓存。 -
有序性：
禁止指令重排序，内部有内存屏障，保证了顺序执行。 -
原子性：
无法保证 -
场景：
-
1.状态量标记
volatile boolean flag；
一个线程写，一个线程读 -
2.单例
-
双重if + volatile
-
对于single = new SingleInstance()；
-
分为三步：
-
1.为变量开辟空间，分配内存 ；2.为对象实例化赋值 3；引用指向内存地址
-
可能会变成 1 3 2，如果其中1 3 执行完，切换到另一个线程，那么此时我们的变量会不是空，但是有一个问题，就是没有初始化，所以会报错。
public class Single{ private Single(){ } private volatile Single singleInstance = null; public getSingle(){ //第一层if，在初始化不用走synchroinzed if(singleInstance == null){ synchronized(Single.class){ //第二层if，防止并发的时候，重复初始化 if(singleInstance == null){ singleInstance = new Single(); } } } return singleInstance; } }
8.volatile和Synchronized的比较
- 前者无法保证原子性，后者可以
- 前者轻量级锁，后者重量级锁
- 前者主要用于变量，后者主要是方法/代码块
- 前者主要体现内存的可见性，后者主要是访问资源的同步性
----------------------------------线程通信方式-----------------------------------------
这三个也是面试常问的，作为线程通信的方法
1.CountDownLatch(CDL)
主要是用于一个线程等待其他完成后才继续执行。
- 主要方法：await()、countDown()
CountDownLatch cdl = new CountDownLatch(2);
//第一个线程
new Thread(){
public void run(){
System.out.println("1111111");
cdl.countDown();
}
}.start();
//第二个线程
new Thread(){
public void run(){
System.out.println("22222222222221111111");
cdl.countDown();
}
}.start();
//主线程
cdl.await();
System0out.println("main执行！！！！！");
2.CyclicBarrier
回环栅栏：主要是用于多个线程在某个点/状态同时执行。
- 主要方法：await()
int N = 4;
CyclicBarrier cb = new CyclicBarrier(N);
for(int i=0;i<N;i++){
new Thread(){
@Override
public void run(){
System.out.println(Thread.currentThread().getName() + "--------");
cb.await();
System.out.println(Thread.currentThread().getName() + "after-------");
}
}
}
注：其await(long timeout,TimeUnit unit)重载方法，让已到达的线程等待至一定的时间，如果还没有到达指定的数量，则这些开始执行。
3.Semaphore
信号量：主要控制访问临界资源的线程数量
- 主要方法：acqurie()、release()
//工人数
int N = 8;
//机器或者说是资源数
Semaphore sp = new Semaphore (5);
for(int i=0;i<N;i++){
new Thread(){
@Override
public void run(){
sp.acquire();
System.out.println("获取机器成功！！");
sp.release();
System.out.println("释放机器！！");
}
}
}
总结：
前两者主要是实现线程之间的等待，而semaphore主要是控制对资源的访问
4.生产者、消费者
开始撸代码了：
4.1 Synchronized
public class MyTest01 {
public class Data{
private int num = 0;
public synchronized void product() throws InterruptedException {
while(num!=0){
this.wait();
}
num++;
System.out.println("生产一个！");
this.notify();
}
public synchronized void consume() throws InterruptedException {
while(num==0){
this.wait();
}
num--;
System.out.println("消费一个！");
this.notify();
}
}
@Test
public void test(){
final Data data = new Data();
//final DataLock data = new DataLock();
//生产者
new Thread(){
public void run(){
for(int i = 0;i<5;i++){
try {
data.product();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}.start();
//消费者
new Thread(){
public void run(){
for(int i = 0;i<5;i++){
try {
data.consume();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}.start();
}
}
4.2 ReentrantLock
public class MyTest01 {
public class DataLock{
private int num = 0;
ReentrantLock lock = new ReentrantLock();
Condition cd = lock.newCondition();
//Condition cd2 = lock.newCondition();
public void product() throws InterruptedException {
lock.lock();
while(num!=0){
cd.await();
}
num++;
System.out.println("生产一个！");
cd.signalAll();
lock.unlock();
}
public void consume() throws InterruptedException {
lock.lock();
while(num==0){
cd.await();
}
num--;
System.out.println("消费一个！");
cd.signal();
lock.unlock();
}
}
@Test
public void test(){
//final Data data = new Data();
final DataLock data = new DataLock();
//生产者
new Thread(){
public void run(){
for(int i = 0;i<5;i++){
try {
data.product();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}.start();
//消费者
new Thread(){
public void run(){
for(int i = 0;i<5;i++){
try {
data.consume();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}.start();
}
}
参考链接：
https://blog.csdn.net/jike11231/article/details/112792709
------------------------------线程：ThreadLocal----------------------------------
目的：每个线程都有自己的变量，线程间的数据的互相隔离，互不影响，存储在每个线程的ThreadLocalMap变量中，是一种类似于HashMap的结构，但是不一样，其没有链表，并且使用的是线性探测法。
1.7的ThreadLocal
- 1.7的threadlocalmap
-
但是，这明显有个问题，如果线程过多（当然一般线程也是多的），那么Entry的数量会很多；并且Thread销毁后，ThreadLocal不能销毁，因为不止一个线程，所以1.8进行了改进，主要看1.8的ThreadLocal。
1.8的ThreadLocal
如上图：一个线程一个ThreadLocalMap，看源码发现：threadlocalMap其实定义是在Threadlocal内部的，有点意思啊
- 基本使用1
- 基本使用2
为每个线程分配一个 JDBC 连接 Connection。这样就可以保证每个线程的都在各自的 Connection 上进行数据库的操作，不会出现 A 线程关了 B线程正在使用的 Connection；
主要方法就是在每个线程中使用set和get即可：
- 1）对于set
public void set(T value) {
Thread t = Thread.currentThread();
ThreadLocalMap map = getMap(t);
if (map != null)
map.set(this, value);
else
createMap(t, value);
}
其实，就是获取当前线程的threadLocalMap，如果为空，则初始化；否则进行在ThreadLocalmap的插入，而这里的插入如下：
private void set(ThreadLocal<?> key, Object value) {
// We don't use a fast path as with get() because it is at
// least as common to use set() to create new entries as
// it is to replace existing ones, in which case, a fast
// path would fail more often than not.
Entry[] tab = table;
int len = tab.length;
int i = key.threadLocalHashCode & (len-1);
for (Entry e = tab[i];
e != null;
e = tab[i = nextIndex(i, len)]) {
ThreadLocal<?> k = e.get();
if (k == key) {
e.value = value;
return;
}
if (k == null) {
replaceStaleEntry(key, value, i);
return;
}
}
tab[i] = new Entry(key, value);
int sz = ++size;
if (!cleanSomeSlots(i, sz) && sz >= threshold)
rehash();
}
分析一下：就是根据key进行定位哪个数组（ThreadlocalMap就是Entry数组），类似于HashMap，如果存在key，直接替换value；
如果不为空，但是key为null，这里说明了内存泄漏了（后面分析），然后使用线性探测法找到为空的（这里不同于hashmap了）
，就直接插入。
- 2）对于get
public T get() {
Thread t = Thread.currentThread();
ThreadLocalMap map = getMap(t);
if (map != null) {
ThreadLocalMap.Entry e = map.getEntry(this);
if (e != null) {
@SuppressWarnings("unchecked")
T result = (T)e.value;
return result;
}
}
return setInitialValue();
}
还是同理获取线程的ThreadLocalmap，然后进行值的获取；没有的话，返回null。
- 3）remove
public void remove() {
ThreadLocalMap m = getMap(Thread.currentThread());
if (m != null)
m.remove(this);
}
在ThreadLocalMap中删除Entry，当然还有内部细节，就不多说了。
3.内存泄漏
我们在上面可以看到：ThreadLocalMap的key—threadlocal其实是一个弱引用。
这会出现内存泄漏问题，但是内存泄漏不是因为弱引用，即使强引用也会出现问题：
-
强引用
使用完ThreadLocal ，thread Local Ref被回收了，所以造成threadLocal无法被回收。
-
弱引用
由于ThreadLocalMap只持有ThreadLocal的弱引用，没有任何强引用指向threadlocal实例, 所以threadlocal就可以顺利被gc回收，此时Entry中的key=null，但是也会又内存泄漏，就是我们无法访问value这快地址了。
-
真实原因
所以跟弱引用和强引用是没有关系的，原因为：
1.没有手动删除这个Entry
2.CurrentThread依然运行对应的方法：
1.使用完ThreadLocal，调用其remove方法删除对应的Entry
2.使用完ThreadLocal，当前Thread也随之运行结束（一般不可控！！！尤其当使用线程池的时候） -
为什么用弱引用？
既然强引用和弱引用都有问题，那为什么用弱引用？
事实上，在ThreadLocalMap中的set/getEntry方法中，会对key为null（也即是ThreadLocal为null）进行判断，如果为null的话， 那么是会对value置为null的。这就意味着使用完ThreadLocal，CurrentThread依然运行的前提下，就算忘记调用remove方法，弱引用比强引用可以多一层保障：弱引用的ThreadLocal会被回收，对应的value在下一次ThreadLocalMap调用set,get,remove中的任一方法的时候会被清除，从而避免内存泄漏。
4351
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
