我们在之前，学习的程序在没有跳转语句的前提下，都是由上至下依次执行，那现在想要设计一个程序，边打游戏边听歌，怎么设计?
要解决上述问题,咱们得使用多进程或者多线程来解决.

并发与并行

并发∶指两个或多个事件在同一个时间段内发生。
并行:指两个或多个事件在同一时刻发生(同时发生)。

并发与并行图解

注意:单核处理器的计算机肯定是不能并行的处理多个任务的，只能是多个任务在单个CPU上并发运行。同理,线程也是一样的，从宏观角度上理解线程是并行运行的，但是从微观角度上分析却是串行运行的，即一个线程一个线程的去运行，当系统只有一个CPU时，线程会以某种顺序执行多个线程，我们把这种情况称之为线程调度。

进程概念

进程：是指一个内存中运行的应用程序，每个进程都有一个独立的内存空间，一个应用程序可以同时运行多个进程;进程也是程序的一次执行过程，是系统运行程序的基本单位;系统运行一个程序即是一个进程从创建、运行到消亡的过程。

进程概念图解

线程概念

线程：线程是进程中的一个执行单元，负责当前进程中程序的执行，一个进程中至少有一个线程。一个进程中是可以有多个线程的，这个应用程序也可以称之为多线程程序。
简而言之：一个程序运行后至少有一个进程，一个进程中可以包含多个线程

线程概念图解

线程与进程

分时调度：所有线程轮流使用CPU的使用权，平均分配每个线程占用CPU的时间。
抢占式调度：优先让优先级高的线程使用CPU，如果线程的优先级相同，那么会随机选择一个(线程随机性)， Java使用的为抢占式调度。
设置线程优先级：

设置线程优先级图解

抢占式调度详解:
大部分操作系统都支持多进程并发运行，现在的操作系统几乎都支持同时运行多个程序。比如∶现在我们上课一边使用编辑器，一边使用录屏软件，同时还开着画图板，dos窗口等软件。此时，这些程序是在同时运行，"感觉这些软件好像在同一时刻运行着”。
实际上，CPU(中央处理器)使用抢占式调度模式在多个线程间进行着高速的切换。对于CPU的一个核而言，某个时刻，只能执行一个线程，而CPU的在多个线程间切换速度相对我们的感觉要快，看上去就是在同一时刻运行。
其实，多线程程序并不能提高程序的运行速度，但能够提高程序运行效率，让CPU的使用率更高。

抢占式调度图解

主线程

主线程：执行主(main)方法的线程
单线程程序：java程序中只有一个线程。执行从main方法开始,从上到下依次执行
JVM执行main方法, main方法会进入到核内存
JVM会找操作系统开辟一条main方法通向cpu的执行路径
cpu就可以通过这个路径来执行main方法
而这个路径有一个名字,叫main(主)线程

public class Person {
  private String name;

  public void run() {
    for (int i = 0; i < 10; i++) {
      System.out.println(name + "--->" + i);
    }
  }

  public Person() {}

  public Person(String name) {
    this.name = name;
  }

  public String getName() {
    return name;
  }

  public void setName(String name) {
    this.name = name;
  }

  @Override
  public String toString() {
    return "Person{" +
      "name='" + name + '\'' +
      '}';
  }
}

public class Demo01 {
  public static void main(String[] args) {
    new Person("张三").run();
    new Person("李四").run();
  }
}

创建多线程的第一种方式_创建线程类

创建多线程程序的第一种方式“创建Thread类的子类”
java.lang.Thread类：是描述线程的类，我们想要实现多线程程序，就必须继承Thread类
实现步骤：
1、创建一个Thread类的子类
2、在Thread类的子类中重写Thread类中的run方法，设置线程任务（开启线程要做什么？）
3、创建Thread类的子类对象
4、调用Thread类中的方法start方法，开启新的线程，执行run方法
void start() 使该线程开始执行，Java虚拟机调用该线程的run方法。
结果是两个线程并发地运行，当前线程（main线程）和另一个线程（创建的新线程，执行其run方法）
多次启动一个线程是非法的，特别是当线程已经结束后，不能再重新启动
Java程序属于抢占式调度，哪个线程优先级高，哪个线程先执行，同一个优先级，随机选择一个执行

// 1、创建一个Thread类的子类
public class MyThread extends Thread {
  // 2、在Thread类的子类中重写Thread类中的run方法，设置线程任务（开启线程要做什么？）
  @Override
  public void run() {
    for (int i = 0; i < 10; i++) {
      System.out.println("run" + i);
    }
  }
}

public class Demo01Thread {
   public static void main(String[] args) {
    // 3、创建Thread类的子类对象
    MyThread myThread = new MyThread();
    // 4、调用Thread类中的方法start方法，开启新的线程，执行run方法
    myThread.run();
    for (int i = 0; i < 10; i++) {
      System.out.println("main" + i);
    }
  }
}

多线程原理_随机性打印结果

多线程原理图解

多线程原理_多线程内存图

多线程原理_多线程内存图

Thread类的常用方法

获取线程名称

获取线程的名称：
1、使用Thread类中的方法getName()
String getName() 返回该线程的名称
2、可以先获取到当前正在执行的线程，使用线程中的方法getName()获取线程的名称
static Thread currentThread() 返回当前正在执行的线程对象的引用
第一种方法

public class MyThread extends Thread {
  // 重写Thread类中的run方法，设置线程任务
  @Override
  public void run() {
    // 获取线程名称
    String name = getName();
    System.out.println(name);
  }
}
结果：
Thread-0
Thread-1
Thread-2

main方法

public class Demo02GetThreadName {
  public static void main(String[] args) {
    // 创建Thread类的子类对象
    MyThread myThread = new MyThread();
    // 调用start()方法，开启新线程，执行run()方法
    myThread.start();
    new MyThread().start();
    new MyThread().start();
  }
}

第二种方法

public class MyThread1 extends Thread {
  // 重写Thread类中的run方法，设置线程任务
  @Override
  public void run() {
    // 获取线程名称
    System.out.println(Thread.currentThread());
  }
}
结果：
Thread[Thread-1,5,main]
Thread[Thread-2,5,main]
Thread[Thread-0,5,main]

设置线程的名称:

1.使用Thread类中的方法setName(名字)
void setName (String name） 改变线程名称，使之与参数name相同。
2创建一个带参数的构造方法,参数传递钱线程的名称;调用父类的带参构造方法,把线程名称传递给父类,让父类(Thread)给子线程起一个名字
Thread(string name) 分配新的Thread对象。
设置Thread类的子类

public class MyThread extends Thread {
  public MyThread() {}

  public MyThread(String name) {
    super(name); // 把线程名称传递给父类，让父类（Thread）给子线程起一个名字
  }

  @Override
  public void run() {
    // 获取线程的名称
    System.out.println(Thread.currentThread().getName());
  }
}

main方法

public static void main(String[] args) {
  // 开启多线程
  MyThread myThread = new MyThread();
  myThread.setName("小强");
  myThread.start(); // 小强

  new MyThread("旺财").start(); // 旺财
}

sleep

public static void sleep(long millis) 使当前正在执行的线程以指定的毫秒数暂停（暂时停止工作）,毫秒数结束之后，线程继续执行

public static void main(String[] args) {
  // 模拟秒表
  for (int i = 1; i <= 60; i++) {
    System.out.println(i);
    // 使用Thread类的sleep方法，让程序睡眠1秒钟
    try {
      Thread.sleep(1000);
    } catch (InterruptedException e) {
      e.printStackTrace();
    }
  }
}

创建多线程的第二种方式_实现Runnable接口

采用 java.lang.Runnable也是非常常见的一种，我们只需要重写run方法即可。
步骤如下:

1、定义Runnable接口的实现类，并重写该接口的run()方法，该run()方法的方法体同样是该线程的线程执行体。
2、创建Runnable实现类的对象，并以此对象作为Thread的target来创建Thread对象，该Thread对象才是真正的线程对象。
3、调用线程对象的start()方法来启动线程。

// 1、定义Runnable接口的实现类，并重写该接口的run()方法，该run()方法的方法体同样是该线程的线程执行体。
public class RunnableImpl implements Runnable {
  @Override
  public void run() {
    for (int i = 0; i < 10; i++) {
      System.out.println(Thread.currentThread().getName());
    }
  }
}

public static void main(String[] args) {
  // 2、创建Runnable实现类的对象，并以此对象作为Thread的target来创建Thread对象，该Thread对象才是真正的线程对象。
  // 3、调用线程对象的start()方法来启动线程。
  new Thread(new RunnableImpl()).start();
  for (int i = 0; i < 10; i++) {
    System.out.println(Thread.currentThread().getName() + i);
  }
}

Thread类和Runnable接口的区别

如果一个类继承Thread ,则不适合资源共享。但是如果实现了Runable接口的话，则很容易的实现资源共享。
总结:

实现Runnable接口比继承Thread类所具有的优势:
1、适合多个相同的程序代码的线程去共享同一个资源。
2、可以避兔java中的单继承的局限性。Java只能单继承，继承Thread类就不能继承其它类，是此案Runnable接口还可以实现其他接口
3、增加程序的健壮性，实现解耦操作，代码可以被多个线程共享，代码和线程独立。实现Runnable接口的方式，把设置线程任务和开启新线程进行了分离（解耦），实现类中重写了run()方法：用来设置线程任务，床技安Thread类对象，调用start方法：用来开启新线程
4、线程池只能放入实现Runable或Callable类线程，不能直接放入继承Thread的类。
扩充∶在java中，每次程序运行至少启动2个线程。一个是main线程，一个是垃圾收集线程。因为每当使用java命令执行一个类的时候，实际上都会启动一个JVM，每一个VM其实在就是在操作系统中启动了一个进程。

匿名内部类方式实现线程的创建

匿名：没有名字
内部类：写在其它类内部的类
匿名内部类的作用：简化代码。把子类继承父类、重写父类方法、创建子类对象合成一步；把实现类实现类接口、重写接口中的方法、创建实现类对象合成一部完成
匿名内部类的最终产物：子类/实现类对象，而这个没有名字
格式：new 父类/接口() { 重复父类/接口中的方法 }

public static void main(String[] args) {
  // 现成的父类使Thread
  new Thread() {
    // 重写run()方法，设置线程任务
    @Override
    public void run() {
      for (int i = 0; i < 10; i++) {
        System.out.println(Thread.currentThread().getName() + i);
      }
    }
  }.start();

  // 线程的接口Runnable
  // RunnableImpl runnable = new RunnableImpl(); // 多态
  Runnable runnable = new Runnable() {
    // 重写run()方法
    @Override
    public void run() {
      for (int i = 0; i < 10; i++) {
        System.out.println(Thread.currentThread().getName() + i + i);
      }
    }
  };
  new Thread(runnable).start();
  // 简写
  new Thread(new Runnable() {
    // 重写run()方法
    @Override
    public void run() {
      for (int i = 0; i < 10; i++) {
        System.out.println(Thread.currentThread().getName() + i + i + i);
      }
    }
  }).start();
}