多线程与高并发一_js中多线程和高并发-CSDN博客

本文链接：https://blog.csdn.net/nmajsjpy/article/details/119988261

线程启动的3种方式

继承Thread
实现Runnable接口
线程池启动

线程的几种方法

sleep睡眠，当前线程暂停一段时间，让给其他线程执行
yield 当前线程调用yield方法，先离开一段时间，进入等待队列里面（英文放弃的意思），等待cpu的调度。让出一下cpu,之后你能不能抢到，我不管，返回到就绪状态
join方法，t1,t2两个线程，在t1某个节点上调用t2.join(),join加入的意思，麻烦你跑到t2去运行，t2运行完了，再回来继续运行t1。
有t1,t2,t3三个线程，如何保证他们的运行顺序，t1调t2.join(),t2调t3.join()

线程的状态

new一个线程，还没有启动start()的时候，状态为new
线程调用start()的方法后，会被线程调度器执行，这个整体状态成为Runnable
Runnable中有两个状态，第一个Ready()就绪状态，Running确实在运行的状态
Ready就绪状态是指，我们扔到等待队列里去了，在对了里面等着，排着队，等着让CPU运行
真正让cup运行的时候叫Running
所以Thread.yield()方法调用的时候会从Running状态跑到Ready状态
线程被调度器选中执行的时候，又从Ready变成Running
线程执行完了，变成Teminated结束状态。Teminated状态结束后，不允许再调用start（）状态
Blocked阻塞，各种锁，等待进入同步代码块时候，还没获取锁去执行代码
Waiting等待，在线程运行的时候，调用了wait(),join(),LookSupport.park(),线程进入Waiting状态
调用o.notify(),o.notifyAll(),LookSupport.unpark();方法，线程继续执行
TimedWaiteing根据时常等待，等时间到了，自己进入Runnable状态
有Thread.sleep(time),o.wait(time),t.join(time),LockSupport.parkNanos(),LockSupport.parkUntil()方法
这些状态都是JVM管理的

锁

为什么要加锁呢，多线程运行的时候，有时会对同一个变量或对象进行操作，所以要加锁保持同步
synchronized 同步锁
synchronized 锁的是谁呢，锁定的某个对象，hostpot底层实现是在对象头上面，这个对象头上面是64位的，拿出两位来，来记录这个对象是否是被锁定了，markword。两位分别是锁的不同组合的类型。所以是拿到这把所之后，我才看下面这段代码我能不能运行。还有一个锁升级的概念

每次定义一个锁的对象太麻烦，每次都要new一个对象出来，所以有一个最简单的方式synchronized(this),锁定当前对象
所以你每次锁定当前对象，完全可以synchironized方法，等同于执行方法时synchronized(this)，锁定当前对象

如果一个静态方法static方法，是没有this对象的，如果在静态方法上加上synchronized，代表synchronized(t.calss)
在加锁程序中可以调用非加锁方法
同一个类中，加锁的两个方法，可以相互调用，不用枪锁，叫做锁的重入
一旦一个线程运行过程中抛出异常，会立刻释放这把锁，其他线程有可能乱入，抢到锁，继续运行

synchronized 底层实现
1.jdk早期的时候,是重量级的，找OS申请锁
后来的改进
是一个锁升级的概念：
百度搜索：我就是厕所所长（一，二）
sync (Object)
markword 记录这个线程的ID(偏向锁)，效率高，不用申请锁，一般就这一个线程执行
如果有线程争用，升级为自旋锁
自旋10次以后，还得不到这把锁
升级为重量级锁==》去OS申请资源

什么时间用自旋锁，什么时间用重量级锁
自旋锁占用cpu资源，重量级锁（OS）不占用cpu资源，而是进入等待队列
执行时间长的线程，用重量级锁
线程执行时间短，但是不能太多，用自旋锁。比如2W个线程，1个在执行，19999个在自旋，cpu也受不了

注意事项：
synchronized 不能锁基本数据类型，String，Integer ，Long，只能锁对象Object

volatile

作用：
1.保证线程可见性
MESI缓存一致性协议
2.禁止指令重排序

注意：
volatile只能保证线程的可见性，并不能替代synchronized,不能保证多线程运行时修改一个值时的数据不一致性问题。
count++,有3个线程，第一个线程运行时，值修改为1，第二个，第三个线程看到的值为1，线程2，线程3都是加一变成2，最终值不是3

synchronized 锁优化问题

同步代码块中的语句越少越好
锁的细化，如果锁的地方只需要一段代码或少量代码，不应该把锁加载整个方法上，而应该把锁加载具体的代码码上

synchronized(this){
	count ++;
}

锁的粗化，如果一个方法中好多地方需要加锁，还不如直接加到方法上，只有一把锁，减少锁的争用

锁定一个对象Object,o，如果o对象的属性发生变化，不影响锁，
如果在特定场景下o变成别的对象了，那么这是线程的并发就会出问题。
所以要对Object对象加锁的时候，前面要加上final

final Object o=new Object();

CAS(无锁优化，自旋，乐观锁)

Java包中的Acomic包中的工具都是CAS实现的

package com.ppt.test;

import java.util.concurrent.atomic.AtomicInteger;

public class AtomicTest {

    public static void main(String[] args) {
        AtomicInteger count=new AtomicInteger();
        //相当于count ++,线程安全的
        count.incrementAndGet();

    }
}

原理：

public final int getAndAddInt(Object var1, long var2, int var4) {
        int var5;
        do {
            var5 = this.getIntVolatile(var1, var2);
        } while(!this.compareAndSwapInt(var1, var2, var5, var5 + var4));

        return var5;
    }

compareAndSwapInt，》 CAS >比较并且设定
V>要改的那个值，
Expected》期望的值
NewValue==》要复制的值

cas(V,Expected,NewValue){
	if(V==E){
		V=E
	}else{
		otherwise try agent or fail
	}
}

CAS的支持，时cpu原语级别的支持，中间不能被打断

ABA问题

进行CAS操作时，两个线程，一个线程比较快，把值先变成A,中间变成B,然后又把值改为A
第二个线程计较慢，看到第一个线程改完之后，值还是A,认为没有问题，会继续执行。
避免ABA问题
加版本号version
A==>1.0
B==>2.0
A==>3.0
检查下版本号
如果是基础类型，无所谓，如果是引用类型，这个对象的引用，不一定是原来的引用了
用的Unsafe类完成的
这个类是单例的
这个类的作用是直接操作内存，相当于c c++的指针