Java多线程的创建与简单使用

一、线程的基本概念

什么是线程：Thread

进程内部的一个执行单元，它是程序中一个单一的顺序控制流程。
线程又被称为轻量级进程(lightweight process)
如果在一个进程中同时运行了多个线程，用来完成不同的工作，则称之为多线程

通俗来讲，在程序中新建一共线程，就好像在程序中新开辟一条道路

二、创建线程的三种方法

1.继承Thread类

　　我们新创建的类可以继承Thread类，并且重写Run方法来实现我们想要的方法，并且通过start()方法来启动这一个线程。

示例如下：

package top.dlkkill.th;

public class MyThread extends Thread{
    
    private String name;
    
    public MyThread(String name) {
        super();
        this.name = name;
    }
    public MyThread() {
        
    }
    @Override
    public void run() {
        // TODO Auto-generated method stub
        for(int i=0;i<20;i++) {
            System.out.println(name+" : "+i);
        }
    }
    
}
//使用如下方式来启动两个线程
public static void test1() {
        MyThread th1=new MyThread("th1");
        MyThread th2=new MyThread("th2");
        th1.start();
        th2.start();
        return;
    }

　　这是创建一共线程最简单的方式，但是有很大的约束，因为在Java中的是单继承的，所以一共类只能继承自另外一个类，所以如果要使用这种方法，就必须使得我们的类要Thread类才可以，这样就使得程序很不灵活，有很大的限制。这样我们就引入了第二种方法。

2.实现Runnable接口（静态代理模式）

1）什么是静态代理模式

代理模式主要包含三个角色，即抽象主题角色(Subject)、委托类角色(被代理角色，Proxied)以及代理类角色(Proxy)，如上图所示：

抽象主题角色:可以是接口，也可以是抽象类；

委托类角色：真实主题角色，业务逻辑的具体执行者；

代理类角色：内部含有对真实对象RealSubject的引用，负责对真实主题角色的调用，并在真实主题角色处理前后做预处理和后处理。

引自：https://blog.csdn.net/justloveyou_/article/details/79407248

而静态代理模式是指在程序运行前由程序员提前写好固定的代码（与之相对的是动态代理模式）

代理模式简单说就是讲自己的事物委托给代理人，由代理人去处理事物开始，运行，结束的事情。

静态代理模式的实现要求：

真实角色
代理角色（持有对真实角色的引用）
二者实现相同的接口

静态代理模式的实现过程：

创建真实角色
创建代理角色+真实角色引用
执行任务

假设我们由一个人要结婚（真实角色），委托给婚庆公司（代理角色），抽象主题就是结婚

代码如下：

package top.dlkkill.th;

public class Example {
    public static void main(String[] args) {
        MarryPeople peo=new MarryPeople();
        MarryConpany conp=new MarryConpany(peo);
        conp.marry();
    }
    
}

interface Marry{
    public void marry();
}
class MarryPeople implements Marry{
    @Override
    public void marry() {
        // TODO Auto-generated method stub
        System.out.println("People Marry");
    }
}
class MarryConpany implements Marry{
    private MarryPeople peo;
    public MarryConpany(MarryPeople peo) {
        super();
        this.peo = peo;
    }
    @Override
    public void marry() {
        // TODO Auto-generated method stub
        before();
        peo.marry();
        after();
    }
    public void before() {
        System.out.println("准备工作");
    }
    public void after() {
        System.out.println("收尾工作");
    }
}

2）Runable创建线程

优点：

避免单继承的局限性
便于共享资源

实现过程如下：

package top.dlkkill.th;

public class MyThread2 implements Runnable{
    private String name;
    private boolean flag=true;
    private int num=50;
    public void setFlag(boolean flag) {
        this.flag = flag;
    }
    @Override
    public void run() {
        // TODO Auto-generated method stub
        while(num>0) {
            System.out.println(Thread.currentThread().getName()+"抢到----->"+num--);
        }
        //System.out.println(name+"------->Stop");
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }

    public MyThread2(String name) {
        super();
        this.name = name;
    }
    public MyThread2() {
        super();
        // TODO Auto-generated constructor stub
    }
    public static void test2() throws InterruptedException {
        MyThread2 myth1=new MyThread2("th1");
        MyThread2 myth2=new MyThread2("th2");
        Thread th1=new Thread(myth1,"路人甲");
        Thread th2=new Thread(myth2,"路人乙");
        th1.start();
        th2.start();
        Thread.sleep(100);
        myth1.setFlag(false);
        myth2.setFlag(false);
        return;
    }
}

这里我们假设一共50张票，路人甲和路人乙进行抢票。
我们创建了两个线程，但是都共享50张票的资源，当50张票抢完后，两个线程自动结束。

3.实现`Callable<V>`接口

这种方法的优点是我们可以抛出我们想要的异常进行异常处理，另外可以得到返回值
但是这种方法的实现过程稍显复杂。

示例如下：

package top.dlkkill.th;

import java.util.concurrent.Callable;

public class MyThread3 implements Callable<Integer> {
    @Override
    public Integer call() throws Exception {
        // TODO Auto-generated method stub
        for(int i=0;i<300;i++)
            continue;
        return 300;
    }
    public static void test3() throws InterruptedException, ExecutionException {
        //创建一个线程
        ExecutorService exe=Executors.newFixedThreadPool(1);
        MyThread3 th=new MyThread3();
        //得到返回值
        Future<Integer> restult=exe.submit(th);
        int num=restult.get();
        System.out.println(num);
        //结束线程
        exe.shutdownNow();
        return;
    }
}

三、线程的状态与终止

1.状态

2.线程的终止

线程的终止有两种情况：

自然终止：线程体正常执行完毕
外部干涉：
- 线程类中定义线程体使用的标识
- 线程体使用该标识
- 提供对外的方法改变该标识
- 外部根据条件调用该方法即可

实例如下:

package top.dlkkill.th;

public class MyThread2 implements Runnable{
    private String name;
    private boolean flag=true;
    private int num=50;
    public void setFlag(boolean flag) {
        this.flag = flag;
    }
    @Override
    public void run() {
        // TODO Auto-generated method stub
        while(flag) {
            //System.out.println(Thread.currentThread().getName()+"抢到----->"+num--);
            System.out.println(name+"----->run");
        }
        System.out.println(name+"------->Stop");
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }

    public MyThread2(String name) {
        super();
        this.name = name;
    }
    public MyThread2() {
        super();
        // TODO Auto-generated constructor stub
    }
    public static void test2() throws InterruptedException {
        MyThread2 myth1=new MyThread2("th1");
        MyThread2 myth2=new MyThread2("th2");
        Thread th1=new Thread(myth1,"路人甲");
        Thread th2=new Thread(myth2,"路人乙");
        th1.start();
        th2.start();
        Thread.sleep(100);
        //标识改变后，线程结束
        myth1.setFlag(false);
        myth2.setFlag(false);
        return;
    }
    
}