进程是一个个应用程序，线程则可以理解为一个应用进程中的多个功能。有了多线程，便可以让程序同时去做多件事情。
并发:在同一时刻，有多个指令在单个CPU上交替执行
并行:在同一时刻，有多个指令在多个CPU上同时执行
多线程实现
在Java中，实现多线程的方法有三种，分别是继承Tread类，重写run方法，第二种便是实现Runnable接口，重写run方法，最后一种便是实现Callable接口。
继承Tread类
public class MyThread extends Thread{
@Override
public void run() {
for(int i=0;i<100;i++){
System.out.println(getName()+"hello world");
}
}
}
将其调用实现：
public class Test {
public static void main(String[] args) {
Thread t1=new MyThread();
Thread t2=new MyThread();
t1.setName("线程1");
t2.setName("线程2");
t1.start();
t2.start();
}
}
当然，如果我们没有给线程设置名字，线程也是有默认的名字的，即Thread-序号，序号由0开始
实现Runnable接口
public class MyRunnable implements Runnable{
@Override
public void run() {
for(int i=0;i<100;i++){
Thread t=Thread.currentThread();
System.out.println(t.getName()+"hello world");
}
}
}
调用该接口实现
public class Test {
public static void main(String[] args) {
//定义多线程要执行的任务
MyRunnable mr=new MyRunnable();
//创建线程对象
Thread t1=new Thread(mr);
Thread t2=new Thread(mr);
t1.setName("线程1");
t2.setName("线程2");
t1.start();
t2.start();
}
}
实现Callable接口
通过Callable接口与Future接口进行实现
这种实现方式的编程相对复杂，但从上面的实现过程中我们发现上述实现都是没有返回值的，那如果我们想要获得多线程的运行结果该怎么办呢？那就可以通过这个方式实现了。
import java.util.concurrent.Callable;
public class MyCallable implements Callable<Integer> {
@Override
public Integer call() throws Exception {
int sum=0;
for(int i=0;i<=100;i++){
sum+=i;
//System.out.println(sum);
}
return sum;
}
}
调用：
//创建Callable对象，表示多线程要执行的任务
MyCallable mc=new MyCallable();
//原本应该使用Future来管理多线程结果的，但由于Future是个接口，因此我们使用其实现类FutureTask
FutureTask<Integer> futureTask=new FutureTask<>(mc);
//创建Thread并启动
Thread t1=new Thread(futureTask);
t1.setName("线程1");
t1.start();
Integer r1=futureTask.get();
System.out.println(r1);
Thread中常见的四个成员方法
setName
设置线程名，需要注意的是，即使我们不给其指定线程名称，他也会有一个默认的线程名。
getName
获取线程名
currentThread()
该方法可以获取当前运行线程的对象。此外，JVM虚拟机启动后，会加载多条线程，其中一条线程便是main线程，即定义在我们的main方法中。如当前我们现在就是在main线中执行的代码。
public static void main(String[] args) throws ExecutionException, InterruptedException {
Thread t1=new MyThread();
Thread t2=new MyThread();
t1.setName("线程1");
System.out.println(Thread.currentThread());
t2.setName("线程2");
t1.start();
System.out.println(t1.currentThread());
t2.start();
线程休眠
调用线程的sleep方法，休眠单位毫秒，1秒=1000毫秒
package Thread;
public class MyThread extends Thread{
@Override
public void run() {
for(int i=0;i<100;i++){
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
System.out.println(getName()+"hello world");
}
}
}
线程的优先级
线程调度方式有两种，分别是抢占式调度和非抢占式调度。
在Java中，采用的是抢占式调度的方式，这就意味着随机性
Java中优先级共分为10档，最低为1，最高为10，在不设定的情况下，默认为5。
Thread t1=new MyThread();
Thread t2=new MyThread();
t1.setName("线程1");
t2.setName("线程2");
t1.setPriority(1);
t2.setPriority(10);
t1.start();
System.out.println(Thread.currentThread().getPriority());
t2.start();
可以看到，由于线程2的优先级较高，因此在前面大多都是线程2在执行，当前的线程是main线程，他的优先级也是5
线程类型
守护线程
守护线程，又称备胎线程，当其他的非守护线程结束后，守护线程也会相继结束。
我们定义两个不同的线程，分别是非守护线程与守护线程，该线程为非守护线程，执行10次。
public class MyTread1 extends Thread{
@Override
public void run() {
for(int i=0;i<10;i++){
System.out.println(getName()+" "+i);
}
}
}
该线程为守护线程，执行100次循环
package Thread.Daemon;
public class MyTread2 extends Thread{
@Override
public void run() {
for(int i=0;i<100;i++){
System.out.println(getName()+" "+i);
}
}
}
我们将后者设置为守护线程,使用setDaemon方法即可。
package Thread.Daemon;
public class Test {
public static void main(String[] args) {
MyTread1 t1=new MyTread1();
MyTread2 t2=new MyTread2();
t2.setDaemon(true);
t1.start();
t2.start();
}
}
随后我们可以看到运行结果，由于非守护线程只运行10次循环，那么根据线程的随机性我们可知非守护线程必定会先执行完毕，此时，守护线程也会陆续停止，这段时间是非守护线程通知守护线程自己已经执行完。
此外，需要注意的是，尽管将线程2设置为守护线程，但其优先级仍默认为5。
那么守护线程有什么业务场景呢，比如说聊天与传输文件：
