一、基本概念

1、进程：是执行中一段程序，即一旦程序被载入到内存中并准备执行，它就是一个进程。进程是表示资源分配的的基本概念，又是调度运行的基本单位，是系统中的并发执行的单位。
2、线程：单个进程中执行中每个任务就是一个线程。线程是进程中执行运算的最小单位。
3、线程是一种轻量级的进程，与进程相比，线程给操作系统带来侧创建、维护、和管理的负担要轻，意味着线程的代价或开销比较小。
4、线程没有地址空间，线程包含在进程的地址空间中。线程上下文只包含一个堆栈、一个寄存器、一个优先权，线程文本包含在他的进程 的文本片段中，进程拥有的所有资源都属于线程。所有的线程共享进程的内存和资源。 同一进程中的多个线程共享代码段(代码和常量)，数据段(全局变量和静态变量)，扩展段(堆存储)。但是每个线程拥有自己的栈段， 寄存器的内容，栈段又叫运行时段，用来存放所有局部变量和临时变量。
5、父和子进程使用进程间通信机制，同一进程的线程通过读取和写入数据到进程变量来通信。
6、进程内的任何线程都被看做是同位体，且处于相同的级别。不管是哪个线程创建了哪一个线程，进程内的任何线程都可以销毁、挂起、恢复和更改其它线程的优先权。线程也要对进程施加控制，进程中任何线程都可以通过销毁主线程来销毁进程，销毁主线程将导致该进程的销毁，对主线程的修改可能影响所有的线程。
7、子进程不对任何其他子进程施加控制，进程的线程可以对同一进程的其它线程施加控制。子进程不能对父进程施加控制，进程中所有线程都可以对主线程施加控制。

总结:进程是所有线程的集合，每一个线程是进程中的一条执行路径。
多线程的目的是为了提高程序效率
可以通过继承Thread或Runnable接口来创建进程

public class ThreadDemo1 extends Thread {
    @Override
    public void run() {
        System.out.println("extends Thread to do Something");
    }
}

public class ThreadDemo2 implements Runnable {
    @Override
    public void run() {
        System.out.println("implements Runnable to do Something");
    }
}

public class main {
    public static void main(String[] args) {
        //1.继承Thread类创建
        new ThreadDemo1().start();
        //2.实现Runnable接口创建
        new Thread(new ThreadDemo2()).start();
        //3。使用匿名内部类创建
        new Thread(() -> {
            System.out.println("Anonymous inner class to do Something");
        }).start();
    }
}
运行得到结果
extends Thread to do Something
implements Runnable to do Something
Anonymous inner class to do Something

二、多线程运行状态

线程从创建、运行到结束总是处于下面五个状态之一：新建状态、就绪状态、运行状态、阻塞状态及死亡状态
1. 新建状态
当用new操作符创建一个线程时，例如new Thread(r)，线程还没有开始运行，此时线程处在新建状态。当一个线程处于新生状态时，程序还没有开始运行线程中的代码

2. 就绪状态
一个新创建的线程并不自动开始运行，要执行线程，必须调用线程的start()方法。当线程对象调用start()方法即启动了线程，start()方法创建线程运行的系统资源，并调度线程运行run()方法。当start()方法返回后，线程就处于就绪状态。 处于就绪状态的线程并不一定立即运行run()方法，线程还必须同其他线程竞争CPU时间，只有获得CPU时间才可以运行线程。因为在单CPU的计算机系统中，不可能同时运行多个线程，一个时刻仅有一个线程处于运行状态。因此此时可能有多个线程处于就绪状态。对多个处于就绪状态的线程是由Java运行时系统的线程调度程序(thread scheduler)来调度的。

3. 运行状态
当线程获得CPU时间后，它才进入运行状态，真正开始执行run()方法.

4. 阻塞状态
线程运行过程中，可能由于各种原因进入阻塞状态:

• 线程通过调用sleep方法进入睡眠状态；
• 线程调用一个在I/O上被阻塞的操作，即该操作在输入输出操作完成之前不会返回到它的调用者；
• 线程试图得到一个锁，而该锁正被其他线程持有；
• 线程在等待某个触发条件；

5. 死亡状态
有两个原因会导致线程死亡：

• run方法正常退出而自然死亡，
• 一个未捕获的异常终止了run方法而使线程猝死。
  为了确定线程在当前是否存活着（就是要么是可运行的，要么是被阻塞了），需要使用isAlive方法。如果是可运行或被阻塞，这个方法返回true；如果线程仍旧是new状态且不是可运行的，或者线程死亡了，则返回false.

三、多线程之间实现同步

1. 什么是多线程安全？
当多个线程同时共享，同一个全局变量或静态变量，做写的操作时，可能会发生数据冲突问题，也就是线程安全问题。做读操作是不会发生数据冲突问题。
2. 如何解决多线程之间线程安全问题?
答:使用多线程之间同步或使用锁(lock)。
3. 为什么使用线程同步或使用锁能解决线程安全问题呢？
将可能会发生数据冲突问题(线程不安全问题)，只能让当前一个线程进行执行。被包裹的代码执行完成后释放锁，让后才能让其他线程进行执行。这样的话就可以解决线程不安全问题。
4. 什么是多线程之间同步？
当多个线程共享同一个资源,不会受到其他线程的干扰。
5. 多线程同步的分类？

• 使用同步代码块(使用自定锁)

synchronized(同一个数据){}

• 使用同步函数(使用this锁)

public synchronized void func() {}

• 静态同步函数(使用该函数所属字节码文件对象锁)

public static synchronized void func() {}

四、多线程之间的死锁

死锁的四个必要条件
1）互斥条件，即某个资源在一段时间内只能由一个线程占有，不能同时被两个或两个以上的线程占有
2）不可抢占条件，线程所获得的资源在未使用完毕之前，资源申请者不能强行地从资源占有者手中夺取资源，而只能由该资源的占有者线程自行释放
3）占有且申请条件，线程至少已经占有一个资源，但又申请新的资源；由于该资源已被另外线程占有，此时该线程阻塞；但是，它在等待新资源之时，仍继续占用已占有的资源。
4）循环等待条件，存在一个线程等待序列{P1，P2，...，Pn}，其中P1等待P2所占有的某一资源，P2等待P3所占有的某一源，......，而Pn等待P1所占有的的某一资源，形成一个线程循环等待环
解决死锁的办法：加锁顺序，死锁检测

下面通过代码实例来讲解一下如何去写一个死锁代码&如何去解决死锁问题

public class DeadLockTest {
    static class MyTask implements Runnable {
        Object obj1 = "obj1";
        Object obj2 = "obj2";
        int flag;
        private void setFlag(int flag) {
            this.flag = flag;
        }
        @Override
        public void run() {
            if (flag == 1) {
                synchronized (obj1) {
                    System.out.println("locking "+obj1);    //占用obj1
                    try {
                        Thread.sleep(3000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    synchronized (obj2) {
                        System.out.println("使用顺序 obj1 -> obj2");
                    }
                }
            } else if (flag == 2) {
                synchronized (obj2) {
                    System.out.println("locking "+obj2);    //占用obj2
                    try {
                        Thread.sleep(3000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    synchronized (obj1) {
                        System.out.println("使用顺序 obj2 -> obj1");
                    }
                }
            }
        }
    }

    public static void main(String[] args) throws InterruptedException {

        MyTask myTask = new MyTask();

        myTask.setFlag(1);
        Thread thread1 = new Thread(myTask);
        thread1.start();

        //保证线程thread1优先执行
        Thread.sleep(100);

        myTask.setFlag(2);
        Thread thread2 = new Thread(myTask);
        thread2.start();
    }
}

通过两个线程去竞争资源从而达到死锁目的
解决方案

        MyTask myTask1 = new MyTask();
        myTask1.setFlag(2);
        Thread thread2 = new Thread(myTask1);
        thread2.start();

理论上是可以解决死锁，但是并没有成功，想了好久原来是字符串常量的问题，需要通过new String()方式解决，即

        Object obj1 = new String("obj1");
        Object obj2 = new String("obj2");