JUC

线程与进程的区别？

并行与并发的区别？

创建线程的方式有哪些？

线程包括哪些状态，状态之间是如何变化的？

新建t1,t2,t3,三个线程如何保证他们按顺序执行？

package juc;
​
import javax.xml.transform.Source;
import java.sql.SQLOutput;
​
public class Myjoin {
​
​
    public static void main(String[] args) {
​
​
       Thread t1=new Thread(()->{
           System.out.println("t1");
       });
​
       Thread t2=new Thread(()->{
           try {
               t1.join();
           }
           catch (InterruptedException e)
           {
               e.printStackTrace();
           }
           System.out.println("t2");
       });
​
​
       Thread t3=new Thread(()->{
           try {
               t2.join();
           }
           catch (InterruptedException e)
           {
               e.printStackTrace();
           }
           System.out.println("t3");
       });
       t3.start();
       t2.start();
       t1.start();
​
​
    }
​
}

notify()和notifyAll()有什么区别？

wait和sleep方法的不同？

如何停止一个正在运行的线程？

package juc;

public class MyInterruot1 extends Thread{

    //线程执行的退出标志
    volatile boolean flag =false;


    @Override
    public void run(){

        while (!flag)
        {
            System.out.println("Mythread.....run....");
            try {
                Thread.sleep(3000);
            }
            catch (InterruptedException e)
            {
                e.printStackTrace();
            }

        }
    }


    public static void main(String[] args) throws InterruptedException {

        //创建Mythread对象
        MyInterruot1 t1=new MyInterruot1();

        t1.start();

        //主线程休眠6秒
        Thread.sleep(6000);

        //更改标记
        t1.flag=true;

        //强制退出
//        t1.stop();

    }

}



public static void main(String[] args) throws InterruptedException {

    //打断阻塞的线程
    Thread t1=new Thread(()->{
        System.out.println("t1 正在运行。。。。。");

        try {
            Thread.sleep(5000);
        }catch (InterruptedException e)
        {
            e.printStackTrace();
        }
    },"t1");

    t1.start();

    Thread.sleep(5000);
    t1.interrupt();
    System.out.println(t1.isInterrupted());
}

synchronized关键字的底层原理？

package juc;
​
public class TickDemo {
​
​
    static Object Lock=new Object();
​
​
​
    int ticketNum=10;
​
    public  void getTicket(){
​
        synchronized (Lock){
            if (ticketNum<=0)
            {
                return ;
            }
            System.out.println(Thread.currentThread().getName()+"抢的一张票，剩余："+ticketNum);
            ticketNum--;
        }
​
    }
​
​
    public static void main(String[] args) {
​
​
        TickDemo tickDemo=new TickDemo();
​
        for(int i=0;i<20;i++)
        {
            new Thread(()->{
                tickDemo.getTicket();
            }).start();
        }
​
    }
​
}
​
​
Thread-0抢的一张票，剩余：10
Thread-19抢的一张票，剩余：9
Thread-18抢的一张票，剩余：8
Thread-17抢的一张票，剩余：7
Thread-16抢的一张票，剩余：6
Thread-15抢的一张票，剩余：5
Thread-3抢的一张票，剩余：4
Thread-13抢的一张票，剩余：3
Thread-1抢的一张票，剩余：2
Thread-11抢的一张票，剩余：1
​
Process finished with exit code 0

​

synchoronize关键字的底层原理-进阶

JMM

CAS

对volatile的理解

volatile禁止指令重排序

什么是AQS

ReentrantLock的实现原理

synchronized和Lock有什么区别？

死锁产生的条件是什么？

聊一聊ConcurrentHashMap

导致并发程序出现问题的根本原因是什么？

原子性

内存的可见性

有序性

防止先读后人

线程池的核心参数

线程中有哪些常见的阻塞队列

如何确定核心线程数

线程池的种类有哪些

为什么不建议用EXecutors创建线程池

这里也没讲清楚，executers有5种静态创建，4个是最大线程数无界，1个是cached queue的队列无界，滥用都会产生OOM问题

OOM(out of Memory)

CountDownLatch

数据汇总

Semaphore

谈谈你对TreadLocal的理解