进程与线程的区别

• 进程：是系统进行分配和管理资源的基本单位
• 线程：进程的一个执行单元，是进程内调度的实体、是CPU调度和分派的基本单位，是比进程更小的独立运行的基本单位。线程也被称为轻量级进程,线程是程序执行的最小单位。
• 一个程序至少一个进程，一个进程至少一个线程。
• 进程有自己的独立地址空间，每启动一个进程，系统就会为它分配地址空间，建立数据表来维护代码段、堆栈段和数据段，这种操作非常昂贵。 而线程是共享进程中的数据的，使用相同的地址空间，因此CPU切换一个线程的花费远比进程要小很多，同时创建一个线程的开销也比进程要小很多。 线程之间的通信更方便，同一进程下的线程共享全局变量、静态变量等数据，而进程之间的通信需要以通信的方式进行。 如何处理好同步与互斥是编写多线程程序的难点。 多进程程序更健壮，进程有独立的地址空间，一个进程崩溃后，在保护模式下不会对其它进程产生影响， 而线程只是一个进程中的不同执行路径。线程有自己的堆栈和局部变量，但线程之间没有单独的地址空间，所以可能一个线程出现问题，进而导致整个程序出现问题

线程的状态及其相互转换

初始(NEW)：新创建了一个线程对象，但还没有调用start()方法。
运行(RUNNABLE):处于可运行状态的线程正在JVM中执行，但它可能正在等待来自操作系统的其他资源，例如处理器。
阻塞(BLOCKED)：线程阻塞于synchronized锁，等待获取synchronized锁的状态。
等待(WAITING)：Object.wait()、join()、 LockSupport.park(),进入该状态的线程需要等待其他线程做出一些特定动作（通知或中断）。
超时等待(TIME_WAITING)：Object.wait(long)、Thread.join()、LockSupport.parkNanos()、LockSupport.parkUntil，该状态不同于WAITING，它可以在指定的时间内自行返回。
终止(TERMINATED)：表示该线程已经执行完毕自己结束，或者产生了异常而结束。

创建线程的方式

• 继承Thread，并重写父类的run方法
• 实现Runable接口，并实现run方法
• 使用匿名内部类
• Lambda表达式
• 线程池

什么是线程安全性

当多个线程访问某个类,不管运行时环境采用何种调度方式或者这些线程如何交替执行,并且在主调代码中不需要任何额外的同步或协同,这个类都能表现出正确的行为,那么就称这个类为线程安全的。----《并发编程实战》

• 什么是线程不安全？
  多线程并发访问时，得不到正确的结果。

原子性操作

一个操作或者多个操作 要么全部执行并且执行的过程不会被任何因素打断，要么就都不执行。
volatile关键字仅仅保证可见性，并不保证原子性 ​ synchronize关机字，使得操作具有原子性。

synchronized关键字

• 内置锁

每个java对象都可以用做一个实现同步的锁，这些锁称为内置锁。线程进入同步代码块或方法的时候会自动获得该锁，在退出同步代码块或方法时会释放该锁。获得内置锁的唯一途径就是进入这个锁的保护的同步代码块或方法。

• 互斥锁

内置锁是一个互斥锁，这就是意味着最多只有一个线程能够获得该锁，当线程A尝试去获得线程B持有的内置锁时，线程A必须等待或者阻塞，直到线程B释放这个锁，如果B线程不释放这个锁，那么A线程将永远等待下去。

• 修饰普通方法：锁住对象的实例
• 修饰代码块： 锁住一个对象 synchronized (lock) 即synchronized后面括号里的内容
• 修饰Class： 锁住整个类
• 修饰静态方法：锁住整个类
  当作用于静态方法时，锁住的是Class实例，又因为Class的相关数据存储在永久带PermGen（jdk1.8则是metaspace），永久带是全局共享的，因此静态方法锁相当于类的一个全局锁，会锁所有调用该方法的线程；

//放在方法 锁得是对象 和 synchronized(this)是一样的
    public synchronized void lockMethod(){
        System.out.println(Thread.currentThread().getName()+" lockMethod");
    }
    
    public void lockMethod_CodeBlockByThis() {
        //代码块 this锁的是对象
        synchronized(this) {
            System.out.println(Thread.currentThread().getName()+" lockMethod_CodeBlockByThis");
        }
    }

    //类锁
    public void lockMethod_CodeBlockByClass() {
        //代码块 Class锁的是类，无论任何地方，任何类只要是锁的是同一个class，并发时都会等待
        synchronized(ThreadDemo.class) {
            System.out.println(Thread.currentThread().getName()+"lockMethod_CodeBlockByClass");
            try {
                Thread.sleep(2000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    //放在静态方法上，锁的是当前的class，此处的锁和synchronized(ClassA.class)是同样的
    public synchronized static void lockStaticMethod() {
        System.out.println(Thread.currentThread().getName()+" lockStaticMethod");

    }

volatile关键字及其使用场景

---

指令重排：CPU和编译器为了提升程序执行的效率，会按照一定的规则允许进行指令优化，在某些情况下，这种优化会带来一些执行的逻辑问题，主要的原因是代码逻辑之间是存在一定的先后顺序，在并发执行情况下，会发生二义性，即按照不同的执行逻辑，会得到不同的结果信息。

---

• 能且仅能修饰变量
• 保证该变量的可见性，volatile关键字仅仅保证可见性，并不保证原子性
• 禁止指令重排序
• A、B两个线程同时读取volatile关键字修饰的对象，A读取之后，修改了变量的值,修改后的值，对B线程来说，是可见
• 使用场景 1：作为线程开关 2：单例，修饰对象实例，禁止指令重排序

单例与线程安全

• 饿汉式--本身线程安全
  在类加载的时候，就已经进行实例化，无论之后用不用到。如果该类比较占内存，之后又没用到，就白白浪费了资源。

public class HungerSingleton {

    private static HungerSingleton ourInstance = new HungerSingleton();

    public static HungerSingleton getInstance() {
        return ourInstance;
    }

    private HungerSingleton() {
    }

}

• 懒汉式 -- 最简单的写法是非线程安全的
  在需要的时候再实例化

public class LazySingleton {

    private static volatile LazySingleton ourInstance = null;

    public static LazySingleton getInstance() {
        if(null == ourInstance){
            synchronized (ourInstance){
                if(ourInstance == null){
                    ourInstance = new LazySingleton();
                }
            }
        }
        return ourInstance;
    }

    private LazySingleton() {
    }
}

如何保证单例？
private私有的空参构造器
static的对象和方法getInstance

如何避免线程安全性问题

• 线程安全性问题成因

   多线程环境
   多个线程操作同一共享资源
   对该共享资源进行了非原子性操作
  

  • 如何避免

  打破成因中三点任意一点
  1：多线程环境--将多线程改单线程（必要的代码，加锁访问）
  2：多个线程操作同一共享资源--不共享资源（ThreadLocal、不共享、操作无状态化、不可变）
  3：对该共享资源进行了非原子性操作-- 将非原子性操作改成原子性操作（加锁、使用JDK自带的原子性操作
  的类、JUC提供的相应的并发工具类）