一、线程的基本概念
什么是线程：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;
}
}