线程的使用

1.run和start的使用

public class Test1 {
    private static class T1 extends Thread{
        @Override
        public void run() {
            for (int i = 0; i < 10; i++) {
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("T1");
            }
        }
    }

    public static void main(String[] args) throws InterruptedException {
        //new T1().run();
        new T1().start();
        for (int i = 0; i < 10; i++) {
            Thread.sleep(1000);
            System.out.println("M1");
        }
    }
}

使用 new T1().run()是先把T1执行完结束，再去执行M1，是只有一个线程去执行。

使用new T1().start();是2个线程去执行，交替。

 

 

2.创建线程的方式

public class Test2 {

    static class MyThread extends Thread {
        @Override
        public void run() {
            System.out.println("第一种方式");
        }
    }

    static class MyRun implements Runnable{

        @Override
        public void run() {
            System.out.println("第二种方式");
        }
    }

    public static void main(String[] args) {
        new MyThread().start();//第一种方式的调用

        new Thread(new MyRun()).start();

        new Thread(()->{
            System.out.println("第二种方式的另一种形式");
        }).start();
    }
}

 

还有一种方式是通过线程池起一个线程。

 

实现与Rnunable的方式，调用的时候需要放在new Thread中。

 

 

3.sleep、yield、join的区别？

sleep()与yield()需要区分比较？

相同点：

　　sleep()方法和yield()方法都是Thread类中的静态方法，都会使当前线程放弃cpu的使用，把cpu的运行机会让给别的线程，sleep()和yield()都不会释放锁。

不同点：

　　1.sleep()方法把cpu让给其它线程，不会考虑其它线程的优先级，因此会给低级别的线程运行cpu的机会；yield()方法只会给与当前线程同一优先级别或者更高优先级的线程运行cpu的机会。

　　2.当线程执行sleep(mils)后，当前线程会进入阻塞状态，参数mils指定休眠时间，休眠时间到后线程进入就绪状态；yield()执行后，当前线程是进入就绪状态。

　　3.sleep()方法申明抛出InterruptedException异常；yield()方法没有申明抛出任何异常。

　　4.sleep()方法比yield()方法具有更好的可移植性。不能依靠yield()方法来提高程序的并 发行能。对于大多数程序员来说，yield()方法的唯一用途是在测试期间人为地提高程 序的并发性能，以帮助发现一些隐藏的错误。

 

join()方法？

　　运行中的线程A，可以调用线程B的join()方法，一旦调用A线程将进入阻塞状态，直到B线程执行结束，A才能恢复到就绪状态。join()有两个重载形式，join()和join(TimeOut)，即可以设置A线程醒来的时间。　

 

 

4.偏向锁、轻量级锁、重量级锁的概念？Synchronized的底层实现

背景，在jdk之前的背景下，使用的都是重量级锁，但是重量级锁需要对线程就行堵塞和唤醒，非常消耗CPU，所以引进了偏向锁和轻量级锁。

 

偏向锁：其实大部分情况下，但是在单线程下执行，并不会有争用。偏向锁就是对对象头记录线程的ID，以后这个线程来执行，可以直接进行操作，不用CAS的消耗。如果出现了线程的争用，就会进入轻量级锁。

 

轻量级锁：线程在执行同步代码块的时候，会尝试使用CAS机制将当前对象头中的锁记录指针指向当前线程，如果失败，则会去使用自旋锁获取（因为一般的线程处理时间比较短，自旋锁就是等待循环一定次数，看占用的线程有没有使用完），如果自旋锁也没有获取到，那就转换为重量级锁。

 

重量级锁：就是一个线程A使用，如果再来一个线程B，线程B堵塞，等线程A使用完，线程B唤醒去执行。

参考：https://www.cnblogs.com/wade-luffy/p/5969418.html

 

5.堆和栈的区别？

https://blog.csdn.net/pt666/article/details/70876410

 

6.volatile的使用及其作用？？

public class Test3 {
    volatile boolean running = true;
    void m(){
        System.out.println("m start");
        while (running){

        }
        System.out.println("m end");
    }

    public static void main(String[] args) throws InterruptedException {
        Test3 test3 = new Test3();
        new Thread(new Runnable() {
            @Override
            public void run() {
                test3.m();
            }
        }).start();

        Thread.sleep(1000);

        test3.running = false;
    }
}

作用1：保证内存的可见性

　　　　在堆内存中，有个共享内存，每个线程也有各自的内容，各自线程都要访问running时，会将共享内存中的running复制一份到自己的内存中，当在线程中更改了running时，什么时候写回共享内存不好控制，所以加了volatile，就能保证了线程之间的可见性。

 

作用2：禁止指令重排序

　　　　

public class Test4 {
    
    private static volatile Test4 INSTANCE;/
    private Test4(){
        
    }
    public static Test4 getInstance(){
        if (INSTANCE == null){   //在第一层判断，是为了节省CPU消耗，不用每次都要线程竞争
            synchronized (Test4.class){//synchronized没有加在方法上，细粒度更细
                if (INSTANCE == null){ //在加一层判断，如果2个线程同时进入，就会被初始化2次
                    INSTANCE = new Test4();
                }
            }
        }
        return INSTANCE;
    }
}

需要加volatile关键字，当进行INSTANCE = new Test4()初始化时，他需要经过三步，首先是在堆中分配内存,给所有属性和方法都被设置成默认值，然后给成员变量初始化。

　　再给对象的属性设置成默认值时，这时候INSTANCE是不为空了，这时线程进入，拿到的对象属性都是默认值，这是不对的。volatile能保证这些全部进行，最后给对象赋值。

 

7.synchronized的可重入

public class Test5 {
    synchronized void m1()  {
        for (int i = 0; i < 10; i++) {
            try{
                Thread.sleep(1000);
            }catch (Exception e){

            }

            System.out.println(i);
            if (i==2)m2();
        }
    }
    synchronized void m2(){
        System.out.println("m2....");
    }

    public static void main(String[] args) {
        Test5 test5 = new Test5();
        new Thread(test5::m1).start();
        
    }
}

在执行m1的方法时候，这个时候是加锁的，然后执行到m2，按理说会产生争用情况，但是在同一个线程中以及synchronized的可重用，所以不会争用。如果是2个线程，这时候重用是没有用的，重用是在一个线程中的时候。

 

 

线程池的使用？

 

　　1.为什么用线程池？解释下线程池参数？

　　　　》降低资源消耗；提高线程利用率，降低创建和销毁线程的消耗。

　　　　》提高相应速度；任务来了，直接有线程可用可执行，而不是创建线程，在执行。

　　　　》提高线程的可管理性；线程是稀缺资源，使用线程池可以统一分配调优监控。

　　　　　　corePoolSize：代表的是核心线程数，也就是正常情况下创建工作的线程数，这些线程创建后并不会消除，而是一种常驻线程。

　　　　　　maxinumPoolSize：代表的是最大线程数，它与核心线程数相对应，表示最大允许被创建的线程数，比如当前任务较多，将核心线程数都用完了，还无法满足需求时，此时就会创建新的线程，但是线程内线程总数不会超过最大线程数。

　　　　　　keepAliveTime、unit：表示超出核心线程数之外的线程的空闲存活时间，也就是核心线程不会消除，但是超出核心线程数的部分线程如果空闲一定的时间则会被消除，我们可以通过setKeepAliveTime来设置空闲时间。

　　　　　　workQueue用来存放待执行的任务，假设我们现在核心线程都已被使用，还有任务进来则全部放入队列，直到整个队列被放满但任务还再持续进入则会开始创建新的线程。

　　　　　　ThreadFactory：实际上是一个线程工厂，用来生产线程执行任务。我们可以选择使用默认的创建工厂，产生的线程都在同一个组内，拥有相同的优先级，且都不是守护线程。当然我们也可以选择自定义线程工厂，一般我们会根据业务来制定不同的线程工厂。

　　　　　　Handler：任务拒绝策略，有两种情况，第一种是当我们调用shutdown等方法关闭线程池后，这时候及时线程池内部还有没执行完的任务正在执行，但是由于线程池已经关闭，我们再继续想线程池提交任务就会遭到拒绝。另一种情况就是当达到最大线程数，线程池已经没有能力继续处理新提交的任务时，这时也是拒绝。

 

 

　　　　线程池的执行顺序？

　　　　　　1.线程池执行任务

　　　　　　2.判断核心线程是否已经满了，没满执行任务，满了下一步

　　　　　　3.判断任务队列是否已经满了，没满将执行任务放入，满了下一步

　　　　　　4.判断线程是否达到最大线程数，没满创建临时线程，满了下一步

　　　　　　5.执行拒绝策略。

　　

 

　　　　线程池中阻塞队列的作用？为什么是先添加队列而不是先创建最大线程？

　　　　　　1.一般的队列只能你保证作为一个有限长度的缓冲区，如果超出了缓冲长度，就无法保留当前的任务了，阻塞队列通过阻塞可以保留住当前想要继续入队的任务。

　　　　　　2.阻塞队列可以保证任务队列中没有任务时阻塞获取任务的线程，使得线程进入wait状态，释放cpu资源

　　　　　　3.阻塞对垒自带阻塞和唤醒的功能，不需要额外处理，无任务执行时，线程池利用阻塞队列的take方法挂起，从而维持核心线程的存活、不至于一直占用cpu资源。