java多线程总结

一、JAVA如何开启线程？怎么保证线程安全？

1.进程和线程的区别
1.进程是资源分配的基本单元，而线程是CPU调度的基本单元。
2.进程有独立的地址空间，线程共享地址空间
3.线程的创建和切换开销比进程小。
4.执行过程：每个独立的进程程有一个程序运行的入口、顺序执行序列和程序入口。但是线程不能独立执行，必须依存在应用程序中，由应用程序提供多个线程执行控制。
5.线程执行开销小，但是不利于资源的管理和保护。

2.如何开启线程
1.继承Thread类。重写run方法。2.实现Runable接口，实现run方法。3.实现Callable接口，实现call方法。通过
FurtherTask创建一个线程，获取线程执行的返回值。4、通过线程池开启线程。

3.怎么保证线程安全？
线程安全：无论怎样交替执行的线程，主程序都不用去同步，得到的结果都是预期的正确结果，就是线程安全。
1.加锁：（1）JVM提供的锁，也就是Synchronized关键字。（2）JDK提供的各种锁。

二、volatile和synchronized有什么区别？volatile能不能保证线程安全？DCL（Double Check Lock）

单例为什么要加volatile？
1.synchronized关键字，用来加锁。volatile只是保证线程变量的可见性。通常用于一个线程写，多个线程读的场景。
2.不能。volatile关键字只能保证线程的可见性，不能保证原子性。但能防止指令重排
3.讲一下Java内存模型

加volatile关键字后

package 多线程.vol;

import java.util.concurrent.TimeUnit;

/**
 * @PackgeName: 多线程.vol
 * @ClassName: VolatileDemo
 * @Author: plxc
 * Date: 2021/5/6 15:51
 * project name: LeetCode
 * @Version:
 * @Description:
 */
public class VolatileDemo {

    private static boolean flag = true;

    public static void main(String[] args) {
        new Thread(()->{
            while (flag){

            };
            System.out.println("Thread is End");
        }).start();
        try {
            TimeUnit.SECONDS.sleep(1);
        }catch (InterruptedException e){
            e.printStackTrace();
        }
        System.out.println("turn flag off");
        flag = false;
    }
}

运行结果：

package 多线程.vol;

import java.util.concurrent.TimeUnit;

/**
 * @PackgeName: 多线程.vol
 * @ClassName: VolatileDemo
 * @Author: plxc
 * Date: 2021/5/6 15:51
 * project name: LeetCode
 * @Version:
 * @Description:
 */
public class VolatileDemo {

    private static volatile boolean flag = true;

    public static void main(String[] args) {
        new Thread(()->{
            while (flag){

            };
            System.out.println("Thread is End");
        }).start();
        try {
            TimeUnit.SECONDS.sleep(1);
        }catch (InterruptedException e){
            e.printStackTrace();
        }
        System.out.println("turn flag off");
        flag = false;
    }
}

运行结果：

三、JAVA线程锁机制是怎样的？偏向锁、轻量级锁、重量级锁有什么区别？锁的机制是如何升级的？

1.JAVA的锁就是在对象的MarkWord中记录的一个状态。无锁，偏向锁，重量级锁对应不同的状态。
2.Java锁机制就是根据资源竞争的激烈程度不断进行锁升级的过程。

四、有三个线程，如何保证三个线程同时执行？如何在并发情况下依次执行？如何保证三个线程有序交错执行？

1.CountDownLatch

   public static void main(String[] args) {
        CountDownLatch countDownLatch = new CountDownLatch(1);
        for (int i = 0; i < 3; i++) {
            new Thread(()->{
                try {
                    countDownLatch.await();
                    System.out.println(System.currentTimeMillis());
                }catch (InterruptedException e){
                    e.printStackTrace();
                }
            }).start();
        }
        countDownLatch.countDown();
    }

运行结果：

2.信号量控制

3.Semaphore

   static Semaphore semaphore1 = new Semaphore(1);
    static Semaphore semaphore2 = new Semaphore(1);
    static Semaphore semaphore3 = new Semaphore(1);

    public static void main(String[] args) {
        try {
            semaphore2.acquire();
            semaphore3.acquire();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        new Thread(() -> {
            for (int i = 0; i < 10; i++) {
                try {
                    semaphore1.acquire();
                    System.out.print("A");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } finally {
                    semaphore2.release();
                }
            }
        }).start();

        new Thread(() -> {
            for (int i = 0; i < 10; i++) {
                try {
                    semaphore2.acquire();
                    System.out.print("B");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } finally {
                    semaphore3.release();
                }
            }
        }).start();

        new Thread(() -> {
            for (int i = 0; i < 10; i++) {
                try {
                    semaphore3.acquire();
                    System.out.println("C");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } finally {
                    semaphore1.release();
                }
            }
        }).start();
    }

运行结果：