进程与线程的区别
- 进程：是系统进行分配和管理资源的基本单位
- 线程：进程的一个执行单元，是进程内调度的实体、是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提供的相应的并发工具类） -
