https://www.bilibili.com/video/BV1G64y1u7zt?from=search&seid=6476405617400132613

理解概念：什么是程序、进程、线程

程序：为了完成特定任务，用某种语言编写的一组指令的集合，即指一个静态的代码，静态对象。
进程：是程序的一次执行过程，或是正在运行的一个程序，是一个动态的过程。有它自身的产生、存在和消亡的过程。

  • 例如运行中的QQ
  • 程序是静态的，进程是动态的
  • 进程作为资源分配的单位，系统在运行时会为每个进程分配不同的内存区域

线程：进程可以进一步细化为线程，是一个程序内部的一条执行路径。

  • 若一个进程同一时间并行执行多个线程，就是支持多线程的
  • 线程作为调度和执行的单位，每个线程拥有独立的运行栈和程序计数器（pc），线程切换的开销小
  • 一个进程中的多个线程，共享相同的内存单元/内存地址空间，也就是多个线程共享同一个进程的方法区和堆， 他们从同一堆中分配对象，可以访问相同的变量和对象。这就使得线程间的通信更简便、高效。但多个线程操作共享的系统资源可能就会带来安全的隐患。

    JVM内存结构

    image.png

    并行与并发的理解

    并行：多个CPU同时执行多个任务
    并发：一个CPU（采用时间片）同时执行多个任务

创建多线程的几种方式

1. 继承Thread类的方式

步骤如下：

  1. 创建一个继承于Thread类的子类
  2. 重写Thread类的run()，将此线程执行的操作写在run()方法内
  3. 创建Thread类的子类对象
  4. 通过调用此对象的start()方法，启动该线程 ```java public class MyThread extends Thread { @Override public void run() { System.out.println(“我是执行的线程”); } }

//使用方式 public class App { public static void main( String[] args ) { MyThread thread=new MyThread(); thread.start(); } }

  1. 说明：
  3. - 启动一个线程，必须调用start()方法，不能调用run()方法。start()方法的作用为 1.启动当前线程。2.调用当前线程的run()方法
  4. - 如果再启动一个线程，必须重新创建Thread类的子对象，调用此对象的start()方法
  6. <a name="8XoOt"></a>
  7. ## 2. 实现Runnable接口的方式
  8. 步骤如下：
  10.    1. 创建一个实现了Runnable接口的类
  11.    1. 实现类中实现Runnable中的抽象方法：run()
  12.    1. 创建实现类的对象
  13.    1. 将此对象作为参数，传递到Thread类的构造器中，创建Thread类的对象
  14.    1. 通过Thread类的对象，调用start()方法启动线程
  15. ```java
  16. public class MyThread implements Runnable {
  18.     @Override
  19.     public void run() {
  20.         System.out.println("我是要执行的线程");
  21.     }
  22. }
  24. //使用方式
  25. public class App 
  26. {
  27.     public static void main( String[] args )
  28.     {
  29.         MyThread myThread=new MyThread();
  30.         Thread thread=new Thread(myThread);
  31.         thread.start();
  32.     }
  33. }

3.匿名内部类的方式

  1. public class App 
  2. {
  3.     public static void main( String[] args )
  4.     {
  5.         new Thread(new Runnable() {
  6.             @Override
  7.             public void run() {
  8.                 System.out.println("我是线程1");
  9.             }
  10.         }).start();
  12.         new Thread(new Runnable() {
  13.             @Override
  14.             public void run() {
  15.                 System.out.println("我是线程2");
  16.             }
  17.         }).start();
  18.     }
  19. }

以上方式的说明
均无返回值
优先选择：实现Runnable接口方式
原因：

  1. 实现的方式没有类的单继承的局限性
  2. 实现的方式更适合来处理多个线程共享数据的情况

Thread类中常用的方法

start() 启动当前线程，并调用当前线程的run()方法
run() 通常需要重写Thread类中的此方法，将线程要执行的方法声明在此方法中
currentThread() 静态方法，返回当前的线程
getName() 获取当前线程的名字
setName(String name) 设置当前线程的名字
yield() 静态方法，释放当前cpu的执行权
join() 在线程a中调用线程b中的join()，此时线程a进入阻塞状态，直到线程b完全执行完以后，线程a才结束阻塞状态
sleep(long millis) 静态方法，让当前线程睡眠指定的时间，当前线程是阻塞状态
isAlive() 判断当前线程是否存活

线程的优先级

  1. public final static int MIN_PRIORITY = 1;//可设置的最小优先级
  3. public final static int NORM_PRIORITY = 5;//默认优先级
  5. public final static int MAX_PRIORITY = 10;//可设置的最大优先级
  1. public final void setPriority(int newPriority) //设置优先级
  3. public final int getPriority() //获取优先级

说明：高优先级的线程要抢占低优先级线程的cpu执行权，但只是从概率上讲，高优先级的线程高概率的情况下被执行，并不意味着只有高优先级的线程执行完之后，低优先级的线程才执行

线程的分类

  • 守护线程
  • 用户线程

守护线程是用来服务用户线程的
将一个线程设置成守护线程的方法 setDaemon(true)
java垃圾回收就是一个典型的守护线程

线程的生命周期

在Thread中的枚举类

  1. public enum State {
  2.     /**
  3.          * Thread state for a thread which has not yet started.
  4.          */
  5.     NEW,
  7.     /**
  8.          * Thread state for a runnable thread.  A thread in the runnable
  9.          * state is executing in the Java virtual machine but it may
  10.          * be waiting for other resources from the operating system
  11.          * such as processor.
  12.          */
  13.     RUNNABLE,
  15.     /**
  16.          * Thread state for a thread blocked waiting for a monitor lock.
  17.          * A thread in the blocked state is waiting for a monitor lock
  18.          * to enter a synchronized block/method or
  19.          * reenter a synchronized block/method after calling
  20.          * {@link Object#wait() Object.wait}.
  21.          */
  22.     BLOCKED,
  24.     /**
  25.          * Thread state for a waiting thread.
  26.          * A thread is in the waiting state due to calling one of the
  27.          * following methods:
  28.          * <ul>
  29.          *   <li>{@link Object#wait() Object.wait} with no timeout</li>
  30.          *   <li>{@link #join() Thread.join} with no timeout</li>
  31.          *   <li>{@link LockSupport#park() LockSupport.park}</li>
  32.          * </ul>
  33.          *
  34.          * <p>A thread in the waiting state is waiting for another thread to
  35.          * perform a particular action.
  36.          *
  37.          * For example, a thread that has called <tt>Object.wait()</tt>
  38.          * on an object is waiting for another thread to call
  39.          * <tt>Object.notify()</tt> or <tt>Object.notifyAll()</tt> on
  40.          * that object. A thread that has called <tt>Thread.join()</tt>
  41.          * is waiting for a specified thread to terminate.
  42.          */
  43.     WAITING,
  45.     /**
  46.          * Thread state for a waiting thread with a specified waiting time.
  47.          * A thread is in the timed waiting state due to calling one of
  48.          * the following methods with a specified positive waiting time:
  49.          * <ul>
  50.          *   <li>{@link #sleep Thread.sleep}</li>
  51.          *   <li>{@link Object#wait(long) Object.wait} with timeout</li>
  52.          *   <li>{@link #join(long) Thread.join} with timeout</li>
  53.          *   <li>{@link LockSupport#parkNanos LockSupport.parkNanos}</li>
  54.          *   <li>{@link LockSupport#parkUntil LockSupport.parkUntil}</li>
  55.          * </ul>
  56.          */
  57.     TIMED_WAITING,
  59.     /**
  60.          * Thread state for a terminated thread.
  61.          * The thread has completed execution.
  62.          */
  63.     TERMINATED;
  64. }

image.png