线程的使用

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的可重用，所以不会争用。