多线程学习记录

进程是一个个应用程序，线程则可以理解为一个应用进程中的多个功能。有了多线程，便可以让程序同时去做多件事情。

并发:在同一时刻，有多个指令在单个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。

那么守护线程有什么业务场景呢，比如说聊天与传输文件：