并发与并行
进程
是指一个内存中运行的应用程序，每个进程都有一个独立的内存空间，一个应用程序可以同时运行多个进程;进程也是程序的一次执行过程，是系统运行程序的基本单位;系统运行一个程序即是一个进程从创建、运行到消亡的过程。
线程
线程是进程中的一个执行单元，负责当前进程中程序的执行，一个进程中至少有一个线程。一个进程中是可以有多个线程的，这个应用程序也可以称之为多线程程序。
简而言之:一个程序运行后至少有一个进程，一个进程中可以包含多个线程
线程调度:
分时调度
所有线程轮流使用CPU的使用权，平均分配每个线程占用CPU的时间。
抢占式调度
优先让优先级高的线程使用CPU，如果线程的优先级相同，那么会随机选择一个(线程随机性)，Java使用的为抢占式调度。
主线程
主线程：执行主方法的线程
单线程程序：Java程序中只有一个线程
执行从main方法开始，从上到下依次执行
public class Demo01MainThread {
public static void main(String[] args) {
Person p1 = new Person("小刘");
p1.run();
Person p2 = new Person("旺财");
p2.run();
}
}
public class Person {
private String name;
public void run(){
//定义循环，执行20次
for (int i = 0; i < 20; i++) {
System.out.println(name + "-->" + i);
}
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public Person(String name) {
this.name = name;
}
public Person() {
}
}
创建多线程的第一种方式
创建多线程程序的第一种方式：创建Thread类的子类
java.lang.Thread类：是描述线程的类，我们想要实现多线程程序，就必须继承Thread类
实现步骤：1、创建一个Thread类的子类
2、在thread类的子类中重写Thread类中的run方法，设置线程任务（开启线程要做什么？）
3、创建Thread类的子类对象
4、调用thread类中的方法start方法，开启新的线程，执行run方法
void start（）使该线程开始执行：Java虚拟机调用该线程的run方法
结果是两个线程并发的运行；当前线程（main线程）和另外一个线程（创建的新线程执行其run方法）
多次启动一个线程是非法的，特别是当线程已经结束执行后，不能在重新启动
Java程序属于抢占式调度，哪个线程的优先级高，哪个线程优先执行，同一个优先级，随机选择一个执行
优缺点
优点：编码简单 缺点：线程类已经继承thread,无法继承其他类，不利于扩展。
主方法
class Demo01Thread {
public static void main(String[] args) {
//3、创建Thread类的子类对象
MyThread mt = new MyThread();
//4、调用thread类中的方法start方法，开启新的线程，执行run方法
mt.start();
for (int i = 0; i < 20; i++) {
System.out.println("main:" + i);
}
}
Thread类的子类
//1、创建一个Thread类的子类
public class MyThread extends Thread{
//2、在thread类的子类中重写Thread类中的run方法，设置线程任务（开启线程要做什么？）
@Override
public void run() {
for (int i = 0; i < 20; i++) {
System.out.println("run:" + i);
}
}
}
多线程原理——随机打印结果
多线程原理——内存图解
获取线程的名称
1、使用Thread类中的getName（）
String getName()返回该线程的名称
2、可以先获取到当前正在执行的线程，使用线程中的方法个体Name（）获取线程名称
static Thread currentThread()返回对当前正在执行的线程对象的引用
//定义一个Thread类的子类
public class MyThread extends Thread{
//重写Thread类中的run方法，设置线程任务
@Override
public void run() {
//获取线程名称
//使用Thread类中的getName（）
String name = getName();
System.out.println(name);
//static Thread currentThread()返回对当前正在执行的线程对象的引用
Thread t = Thread.currentThread();
System.out.println(t);//Thread[Thread-0,5,main]
//链式编程
System.out.println(Thread.currentThread().getName());
}
}
/*
* 线程的名称：
* 主线程：main
* 新线程：Thread-0,Thread-1,Thread-2
* */
public class Demo01GetThreadName {
public static void main(String[] args) {
//创建Thread类的子类对象
MyThread mt = new MyThread();
//调用start方法，开启新线程，执行run方法
mt.start();//Thread-0
new MyThread().start();//Thread-1
//获取主线程的名称
System.out.println(Thread.currentThread().getName());
}
}
设置线程的名称
1、使用Thread类中的方法setName（名字）
void setName（String name）
改变线程名称，使之与参数name相同
2、创建一个带参数的构造方法，参数传递线程名称，调用父类的带参构造方法，把线程名称传递给父类，让父类（Thread）给子线程起起名字
Thread（String name）分配新的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());
}
}
public class Demo01GetThreadName {
public static void main(String[] args) {
//开启多线程
MyThread mt = new MyThread();
mt.setName("蹦蹦蹦");
mt.start();//蹦蹦蹦,当使用setName设置线程名称为“蹦蹦蹦”后，start方法获取到的线程名称就为“蹦蹦蹦”
//开启多线程
new MyThread("小甜甜").start();//
}
}
设置线程sleep
public static void sleep(long millis): 使当前正在执行的线程以指定的毫秒数暂停（暂时停止执行）
毫秒数结束后，继续执行
public class Demo01Sleep {
public static void main(String[] args) {
//模拟秒表
for (int i = 1; i <= 60; i++) {
try {
//使用Thread类的sleep方法让线程睡眠1秒钟
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(i);
}
}
}
1、为什么不直接调用run方法，而是调用start启动线程。
直接调用run方法会当成普通方法执行，此时相当于还是单线程执行。
只有调用start方法才是启动一个新的线程执行。
2、为什么不能把主线程的任务放到子线程之前
这样主线程一直是先跑完，相当于是一个单线程的效果了。
创建多线程的第二种方式
创建多线程程序的第二种方式：实现Runnable接口
Java.lang.Runnable
Runnable接口应该由那些打算通过某一线程执行其实例的类来实现。类必须定义一个称为run的无参数方法
Java.lang.Thread类的构造方法
Thread(Runnable target)分配新的Thread对象
Thread(Runnable target，String name)分配新的Thread对象
实现步骤：
1、创建一个Runnable接口的实现类
2、在实现类中重写Runnable接口的run方法，设置线程任务
3、创建一个Runnable接口的实现类对象
4、创建Thread类对象，构造方法中传递Runnable接口的实现类对象
5、调用Thread类中的start方法，开启新的线程执行run方法
优点：线程任务类只是实现了Runnale接口，可以继续继承和实现
缺点：如果线程有执行结果是不能直接返回的
//1、创建一个Runnable接口的实现类
public class Runnableimpl implements Runnable{
@Override
//2、在实现类中重写Runnable接口的run方法，设置线程任务
public void run() {
for (int i = 0; i < 20; i++) {
System.out.println(Thread.currentThread().getName() + "-->" +i);
}
}
}
public class Demo01Runnable {
public static void main(String[] args) {
//3、创建一个Runnable接口的实现类对象
Runnable run = new Runnableimpl();
//4、创建Thread类对象，构造方法中传递Runnable接口的实现类对象
Thread t = new Thread(run);
//5、调用Thread类中的start方法，开启新的线程执行run方法
t.start();
for (int i = 0; i < 20; i++) {
System.out.println(Thread.currentThread().getName() + "-->" +i);
}
}
}
Thread和Runnable的区别
如果一个类继承Thread，则不适合资源共享。但是如果实现了Runable接口的话，则很容易的实现资源共享。
总结:
实现Runnable接口比继承Thread类所具有的优势:
1.适合多个相同的程序代码的线程去共享同一个资源。
2.可以避兔java中的单继承的局限性。
3.增加程序的健壮性，实现解耦操作，代码可以被多个线程共享，代码和线程独立。
4.线程池只能放入实现Runable或Callable类线程，不能直接放入继承Thread的类。
扩充:
在java中，每次程序运行至少启动2个线程。一个是main线程，一个是垃圾收集线程。因为每当使用java命令执行一个类的时候，实际上都会启动一个JVM，每一个JVM其实在就是在操作系统中启动了一个进程。
匿名内部类方式实现线程的创建
匿名:没有名字
内部类:写在其他类内部的类
匿名内部类作用:简化代码
把子类继承父类,重写父类的方法,创建子类对象合一步完成
把实现类实现类接口,重写接口中的方法,创建实现类对象合成一步完成
匿名内部类的最终产物:子类/实现类对象,而这个类没有名字
格式：new 父类/接口（）{
重写父类/接口中的方法
};
public class Demo01InnerClassThread {
public static void main(String[] args) {
//线程的父类是Thread
//new MyThread().start();
new Thread(){
//重写run方法，设置线程任务
@Override
public void run() {
for (int i = 0; i < 20; i++) {
System.out.println(Thread.currentThread().getName() + "-->" + "好累");
}
}
}.start();
//线程的接口Runnable
//Runnableimpl r = new Runnableimpl();
Runnable r = new Runnable(){
//重写run方法，设置线程任务
@Override
public void run() {
for (int i = 0; i < 20; i++) {
System.out.println(Thread.currentThread().getName() + "-->" + "睡觉");
}
}
};
new Thread(r).start();
//简化接口的方式
new Thread(new Runnable(){
//重写run方法，设置线程任务
@Override
public void run() {
for (int i = 0; i < 20; i++) {
System.out.println(Thread.currentThread().getName() + "-->" + "废物");
}
}
}).start();
}
}
创建多线程的第三种方式
前两种线程都存在一个问题，他们重写的run方法均不能直接返回结果。
不适合需要返回线程执行结果的业务场景。
实现方式
1、得到任务对象
定义类实现Callable接口，重写call方法，封装要做的事情。
用FutureTask把Callable对象封装成为线程任务对象。
2、把线程任务对象交给Thread处理。
3、调用Thread的start方法启动线程，执行任务。
4、线程执行完毕后，通过FutureTask的get方法获取任务执行的结果。
//3、创建Callable任务对象
Callable<String> call = new MyCallable(100);
//4、把Callable任务对象，交给FutureTask
//FutureTask对象的作用，是Runnable的对象，可以交给Thread
//可以在线程执行完毕后，通过get方法得到线程执行完成的记过
FutureTask<String> f1 = new FutureTask<>(call);
//5、交给线程处理
Thread t1 = new Thread(f1);
//6、启动线程
t1.start();
Callable<String> call2 = new MyCallable(200);
FutureTask<String> f2 = new FutureTask<>(call);
Thread t2 = new Thread(f1);
t2.start();
try {
String s = f1.get();
System.out.println("第一个结果" + s);
} catch (Exception e) {
e.printStackTrace();
}
try {
String s1 = f2.get();
System.out.println("第二个结果" + s1);
} catch (Exception e) {
e.printStackTrace();
}
}
}
//1、定义一个任务类，实现Callable接口,应该声明线程任务执行完毕后结果的数据类型
class MyCallable implements Callable<String>{
private int n;
public MyCallable(int n){
this.n = n;
}
@Override
//2、重写call方法（任务方法）
public String call() throws Exception {
int sun = 0;
for (int i = 0; i < n; i++) {
sun += 1;
}
return "子线程执行的结果是：" + sun;
}
}
优点：线程任务类只是实现接口，可以继续继承类和实现接口，扩展性强。可以在线程执行完毕后获取线程执行的结果。
缺点：编码复杂。
Thread常用API
Thread常用方法：获取线程名称getName()、设置名称setName()、获取当前线程对象currentThread()。
至于Thread类提供的诸如：yield、join、interrupt、不推荐的方法stop、守护线程、线程优先级等线程的控制方法，在开发中很少使用。
String getName() 获取当前线程的名称，默认线程名称是Thread-索引。
void setName(String name) 将此线程的名称更改为指定的名称，通过构造器可以设置线程名称。
public static Thread currentThread() 返回对当前正在执行的线程对象的引用。
public static void sleep(long time) 让当前线程休眠指定的时间后再继续执行，单位为毫秒