原?性:
?个不可再被分割的颗粒，原?性指的是?个或多个操作要么全部执?成功要么全部执?失败，期间不能被中断，也不存在上下?切换，线程切换会带来原?性的问题
int num = 1; // 原?操作
num++; // ?原?操作，从主内存读取num到线程?作内存，进? +1，再把num写到主内存, 除??原?类，即java.util.concurrent.atomic?的原?变量类
解决办法：可以?synchronized 或 Lock(?如ReentrantLock) 来把这个多步操作“变成”原?操作，但是volatile，前?有说到不能修饰有依赖值的情况
有序性:
程序执?的顺序按照代码的先后顺序执?，因为处理器可能会对指令进?重排序 JVM在编译java代码或者CPU执?JVM字节码时，对现有的指令进?重新排序，主要?的是优化运?效率(不改变程序结果的前提)
可?性:
?个线程A对共享变量的修改,另?个线程B能够?刻看到
// 线程 A 执?
int num = 0;
// 线程 A 执?
num++;
// 线程 B 执?
System.out.print(“num的值：” + num);
线程A执? i++ 后再执?线程 B，线程 B可能有2个结果，可能是0和1。 因为 i++ 在线程A中执?运算，并没有?刻更新到主内存当中，?线程B就去主内存当中读取并打 印，此时打印的就是0；也可能线程A执?完成更新到主内存了,线程B的值是1。
所以需要保证线程的可?性 synchronized、lock和volatile能够保证线程可?性
先来先服务调度算法： 按照作业/进程到达的先后顺序进?调度，即：优先考虑在系统中等待时间最?的作业，排在?进程后的短进程的等待时间?，不利于短作业/进程
短作业优先调度算法： 短进程/作业（要求服务时间最短）在实际情况中占有很??例，为了使得它们优先执?，对?作业不友好
?响应?优先调度算法: 在每次调度时，先计算各个作业的优先权：优先权=响应?=（等待时间+要求服务时间）/ 要求服务时间, 因为等待时间与服务时间之和就是系统对该作业的响应时间，所以优先权=响应?=响应 时间/要求服务时间，选择优先权?的进?服务需要计算优先权信息，增加了系统的开销
时间?轮转调度算法: 轮流的为各个进程服务，让每个进程在?定时间间隔内都可以得到响应 由于?频率的进程切换，会增加了开销，且不区分任务的紧急程度
优先级调度算法: 根据任务的紧急程度进?调度，?优先级的先处理，低优先级的慢处理 如果?优先级任务很多且持续产?，那低优先级的就可能很慢才被处理
线程调度是指系统为线程分配CPU使?权的过程，主要分两种：
协同式线程调度(分时调度模式)：线程执?时间由线程本身来控制，线程把??的?作执?完之后，要主动通知系统切换到另外?个线程上。最?好处是实现简单，且切换操作对线程??是可知的，没啥线程同步问题。坏处是线程执?时间不可控制，如果?个线程有问题，可能?直阻塞在那?
抢占式线程调度：每个线程将由系统来分配执?时间，线程的切换不由线程本身来决定（Java中，Thread.yield()可以让出执?时间，但?法获取执?时间）。线程执?时间系统可控，也不会有?个线程导致整个进程阻塞
Java线程调度就是抢占式调度,优先让可运?池中优先级?的线程占?CPU,如果可运?池中的线程优先级相同,那就随机选择?个线程 所以我们如果希望某些线程多分配?些时间，给?些线程少分配?些时间，可以通过设置线程优先级来完成。
JAVA的线程的优先级，以1到10的整数指定。当多个线程可以运?时，VM?般会运?最?优先级的线 程（Thread.MIN_PRIORITY?Thread.MAX_PRIORITY）
在两线程同时处于就绪runnable状态时，优先级越?的线程越容易被系统选择执?。但是优先级并不是100%可以获得，只不过是机会更??已。
有?会说，wait,notify不就是线程本身控制吗？ 其实不是，wait是可以让出执?时间，notify后?法获取执?时间，随机等待队列??获取?已
悲观锁：当线程去操作数据的时候，总认为别的线程会去修改数据，所以它每次拿数据的时候都会上锁，别的线程去拿数据的时候就会阻塞，?如synchronized
乐观锁：每次去拿数据的时候都认为别?不会修改，更新的时候会判断是别?是否回去更新数据，通过版本来判断，如果数据被修改了就拒绝更新，?如CAS是乐观锁，但严格来说并不是锁，通过原?性来保证数据的同步，?如说数据库的乐观锁，通过版本控制来实现，CAS不会保证线程同步，乐观的认为在数据更新期间没有其他线程影响
?结：悲观锁适合写操作多的场景，乐观锁适合读操作多的场景，乐观锁的吞吐量会?悲观锁多
公平锁：指多个线程按照申请锁的顺序来获取锁，简单来说 如果?个线程组?，能保证每个线程都能拿到锁 ?如ReentrantLock(底层是同步队列FIFO:First Input First Output来实现)
?公平锁：获取锁的?式是随机获取的，保证不了每个线程都能拿到锁，也就是存在有线程饿死,?直拿不到锁，?如synchronized、ReentrantLock
?结：?公平锁性能?于公平锁，更能重复利?CPU的时间
可重?锁：也叫递归锁，在外层使?锁之后，在内层仍然可以使?，并且不发?死锁
不可重?锁：若当前线程执?某个?法已经获取了该锁，那么在?法中尝试再次获取锁时，就会获取不到被阻塞
?结：可重?锁能?定程度的避免死锁 synchronized、ReentrantLock 重?锁
?旋锁：?个线程在获取锁的时候，如果锁已经被其它线程获取，那么该线程将循环等待，然后不断的判断锁是否能够被成功获取，直到获取到锁才会退出循环,任何时刻最多只能有?个执?单元获得锁.
?结：不会发?线程状态的切换，?直处于?户态，减少了线程上下?切换的消耗，缺点是循环会消耗CPU
常?的?旋锁：TicketLock,CLHLock,MSCLock
共享锁：也叫S锁/读锁，能查看但?法修改和删除的?种数据锁，加锁后其它?户可以并发读取、查询数据，但不能修改，增加，删除数据，该锁可被多个线程所持有，?于资源数据共享
互斥锁：也叫X锁/排它锁/写锁/独占锁/独享锁/ 该锁每?次只能被?个线程所持有,加锁后任何线程试图再次加锁的线程会被阻塞，直到当前线程解锁。例?：如果线程A对 data1 加上排他锁后，则其他线程不能再对 data1 加任何类型的锁,获得互斥锁的线程即能读数据?能修改数据
死锁：两个或两个以上的线程在执?过程中，由于竞争资源或者由于彼此通信?造成的?种阻塞的现象，若?外?作?，它们都将?法让程序进?下去
下?三种是Jvm为了提?锁的获取与释放效率?做的优化 针对Synchronized的锁升级（1.6），锁的状态是通过 对象监视器在对象头中的字段来表明，是不可逆的过程
偏向锁：?段同步代码?直被?个线程所访问，那么该线程会?动获取锁，获取锁的代价更低
轻量级锁：当锁是偏向锁的时候，被其他线程访问，偏向锁就会升级为轻量级锁，其他线程会通过?旋的形式尝试获取锁，但不会阻塞，且性能会?点
重量级锁：当锁为轻量级锁的时候，其他线程虽然是?旋，但?旋不会?直循环下去，当?旋?定次数的时 候且还没有获取到锁，就会进?阻塞，该锁升级为重量级锁，重量级锁会让其他申请的线程进?阻塞，性能也会降低
分段锁、?锁、表锁
线程在获得了锁A并且没有释放的情况下去申请锁B，这时另?个线程已经获得了锁B，在释放锁B之前?要先获得锁A，因此闭环发?，陷?死锁循环
public class DeadLockDemo {
private static String locka = "locka";
private static String lockb = "lockb";
public void methodA(){
? synchronized (locka){
? System.out.println("我是A?法中获得了锁A "+Thread.currentThread().getName() );
? //让出CPU执?权，不释放锁
? try {
? Thread.sleep(2000);
? } catch (InterruptedException e) {
? e.printStackTrace();
? }
? synchronized(lockb){
? System.out.println("我是A?法中获得了锁B "+Thread.currentThread().getName() );
? }
? }
}
public void methodB(){
? synchronized (lockb){
? System.out.println("我是B?法中获得了锁B "+Thread.currentThread().getName());
? //让出CPU执?权，不释放锁
? try {
? Thread.sleep(2000);
? } catch (InterruptedException e) {
? e.printStackTrace();
? }
? synchronized(locka){
? System.out.println("我是B?法中获得了锁A "+Thread.currentThread().getName() );
? }
? }
}
public static void main(String [] args){
? System.out.println("主线程运?开始运 ?："+Thread.currentThread().getName());
DeadLockDemo deadLockDemo = new DeadLockDemo();
new Thread(()->{ deadLockDemo.methodA(); }).start();
new Thread(()->{ deadLockDemo.methodB(); }).start();
System.out.println("主线程运?结束："+Thread.currentThread().getName());
}
}
死锁的4个必要条件
互斥条件：资源不能共享，只能由?个线程使?
请求与保持条件：线程已经获得?些资源，但因请求其他资源发?阻塞，对已经获得的资源保持不释放
不可抢占：有些资源是不可抢占的，当某个线程获得这个资源后，系统不能强?回收，只能由线程使?完??释放
循环等待条件：多个线程形成环形链，每个都占?对?申请的下个资源
只要发?死锁，上?的条件都成?；只要?个不满?，就不会发?死锁
●上面的例子怎么解决死锁，优化下代码
○调整申请锁的范围
○调整申请锁的顺序
public class DeadLockDemo {
private static String locka = "locka";
private static String lockb = "lockb";
public void methodA(){
? synchronized (locka){
? System.out.println("我是A?法中获得了锁A "+Thread.currentThread().getName() );
? //让出CPU执?权，不释放锁
? try {
? Thread.sleep(2000);
? } catch (InterruptedException e) {
? e.printStackTrace();
? }
? }
? synchronized(lockb){
? System.out.println("我是A?法中获得了锁B "+Thread.currentThread().getName() );
? }
}
public void methodB(){
? synchronized (lockb){
? System.out.println("我是B?法中获得了锁B "+Thread.currentThread().getName());
? //让出CPU执?权，不释放锁
? try {
? Thread.sleep(2000);
? } catch (InterruptedException e) {
? e.printStackTrace();
? }
? }
? synchronized(locka){
? System.out.println("我是B?法中获得了锁A "+Thread.currentThread().getName() );
? }
}
public static void main(String [] args){
? System.out.println("主线程运?开始运 ?："+Thread.currentThread().getName());
DeadLockDemo deadLockDemo = new DeadLockDemo();
new Thread(()->{ deadLockDemo.methodA(); }).start();
new Thread(()->{ deadLockDemo.methodB(); }).start();
System.out.println("主线程运?结束："+Thread.currentThread().getName());
}
}
//不可重?锁：若当前线程执?某个?法已经获取了该锁，那么在?法中尝试再次获取锁时，就会获取 不到被阻塞
public class UnreentrantLock {
private boolean isLocked = false;
public synchronized void lock() throws InterruptedException {
? System.out.println("进?lock加锁 "+Thread.currentThread().getName());
? //判断是否已经被锁，如果被锁则当前请求的线程进?等待
? while (isLocked){
? System.out.println("进?wait等待 "+Thread.currentThread().getName());
? wait();
? }
? //进?加锁
? isLocked = true;
}
public synchronized void unlock(){
System.out.println("进?unlock解锁 "+Thread.currentThread().getName());
isLocked = false;
//唤醒对象锁池??的?个线程
notify();
}
}
public class Main {
private UnreentrantLock unreentrantLock = new UnreentrantLock();
//加锁建议在try??，解锁建议在finally
public void methodA(){
? try {
? unreentrantLock.lock();
? System.out.println("methodA?法被调?");
? methodB();
? } catch (InterruptedException e){
? e.fillInStackTrace();
? } finally {
? unreentrantLock.unlock();
? }
}
public void methodB(){
? try {
? unreentrantLock.lock();
? System.out.println("methodB?法被调?");
? } catch (InterruptedException e){
? e.fillInStackTrace();
? } finally {
? unreentrantLock.unlock();
? }
}
public static void main(String [] args){
//演示的是同个线程
new Main().methodA();
}
}
//同?个线程，重复获取锁失败，形成死锁，这个就是不可重?锁
//可重入锁：也叫递归锁，在外层使?锁之后，在内层仍然可以使?，并且不发?死锁
public class ReentrantLock {
private boolean isLocked = false;
//?于记录是不是重?的线程
private Thread lockedOwner = null;
//累计加锁次数，加锁?次累加1，解锁?次减少1
private int lockedCount = 0;
public synchronized void lock() throws InterruptedException {
? System.out.println("进?lock加锁 "+Thread.currentThread().getName());
? Thread thread = Thread.currentThread();
? //判断是否是同个线程获取锁, 引?地址的?较
? while (isLocked && lockedOwner != thread ){
? System.out.println("进?wait等待 "+Thread.currentThread().getName());
? System.out.println("当前锁状态 isLocked = "+isLocked);
? System.out.println("当前count数量 lockedCount = "+lockedCount);
? wait();
? }
? //进?加锁
? isLocked = true;
? lockedOwner = thread;
? lockedCount++;
}
public synchronized void unlock(){
? System.out.println("进?unlock解锁 "+Thread.currentThread().getName());
? Thread thread = Thread.currentThread();
? //线程A加的锁，只能由线程A解锁，其他线程B不能解锁
? if(thread == this.lockedOwner){
? lockedCount--;
? if(lockedCount == 0){
? isLocked = false;
? lockedOwner = null;
? //唤醒对象锁池??的?个线程
? notify();
? }
? }
}
}
public class Main {
private ReentrantLock reentrantLock = new ReentrantLock();
//加锁建议在try??，解锁建议在finally
public void methodA(){
try {
? reentrantLock.lock();
? System.out.println("methodA?法被调?");
? methodB();
} catch (InterruptedException e){
? e.fillInStackTrace();
} finally {
? reentrantLock.unlock();
}
}
public void methodB(){
try {
? reentrantLock.lock();
? System.out.println("methodB?法被调?");
} catch (InterruptedException e){
? e.fillInStackTrace();
} finally {
? reentrantLock.unlock();
}
}
public static void main(String [] args){
for(int i=0 ;i<10;i++){
? //演示的是同个线程
? new Main().methodA();
}
}
}
## 8.对sychronized了解吗，介绍下对它的理解
synchronized是解决线程安全的问题，常?在 同步普通?法、静态?法、代码块 中 ?公平、可重?
每个对象有?个锁和?个等待队列，锁只能被?个线程持有，其他需要锁的线程需要阻塞等待。锁被释放后，对象会从队列中取出?个并唤醒，唤醒哪个线程是不确定的，不保证公平性
两种形式：
1.?法：?成的字节码?件中会多?个 ACC_SYNCHRONIZED 标志位，当?个线程访问?法时，会去检查是否存在ACC_SYNCHRONIZED标识，如果存在，执?线程将先获取monitor，获取成功之后才能执??法体，?法执?完后再释放monitor。在?法执?期间，其他任何线程都?法再获得同?个monitor对象，也叫隐式同步
2.代码块：加了 synchronized 关键字的代码段，?成的字节码?件会多出 monitorenter 和 monitorexit 两条指令，每个monitor维护着?个记录着拥有次数的计数器, 未被拥有的monitor的该计数器为0，当?个线程获执?monitorenter后，该计数器?增1;当同?个线程执?monitorexit指令的时候，计数器再?减1。当计数器为0的时候,monitor将被释放.也叫显式同步
两种本质上没有区别，底层都是通过monitor来实现同步, 只是?法的同步是?种隐式的?式来实现，?需通过字节码来完成
有得到锁的资源进?Block状态,涉及到操作系统?户模式和内核模式的切换，代价?较?
jdk1.6进?了优化，增加了从偏向锁到轻量级锁再到重量级锁的过渡，但是在最终转变为重量级锁之后，性 能仍然较低
## 9.了解CAS吗，解释一下
全称是Compare And Swap，即?较再交换，是实现并发应?到的?种技术
底层通过Unsafe类实现原?性操作。
操作包含三个操作数：内存地址（V）、预期原值（A）和新值 (B)。
如果内存位置的值（V）与预期原值相（A）匹配，那么处理器会?动将该位置值更新为新值 ，若果在第?轮循环中，a线程获取地址??的值（V）被b线程修改了，那么a线程需要?旋，到下次循环才有可能机会执?。
CAS这个是属于乐观锁，性能较悲观锁有很?的提? AtomicXXX 等原?类底层就是CAS实现，?定程度?synchonized好，因为后者是悲观锁
## 10.CAS会存在什么比较严重的问题
1、?旋时间?CPU利?率增加，CAS??是?个循环判断的过程，如果线程?直没有获取到状态，cpu资源会?直被占?
2、存在ABA问题
11.什么是ABA问题，如何避免
如果?个变量V初次读取是A值，并且在准备赋值的时候也是A值，那就能说明A值没有被修改过吗？
其实是不能的，因为变量V可能被其他线程改回A值，结果就是会导致CAS操作误认为从来没被修改过，从?赋值给V
给变量加?个版本号即可，在?较的时候不仅要?较当前变量的值 还需要?较当前变量的版本号。 在java5中，已经提供了AtomicStampedReference来解决问题，检查当前引?是否等于预期引 ?，其次检查当前标志是否等于预期标志，如果都相等就会以原?的?式将引?和标志都设置为新值