Java多线程的创建与结束

一、线程的基本概念

什么是线程:Thread

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

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

二、创建线程的三种方法

1.继承Thread类

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

示例如下:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
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

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

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

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

  1. 真实角色
  2. 代理角色(持有对真实角色的引用)
  3. 二者实现相同的接口

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

  1. 创建真实角色
  2. 创建代理角色+真实角色引用
  3. 执行任务

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

代码如下:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
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创建线程

优点:

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

实现过程如下:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
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>接口

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

示例如下:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
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.线程的终止

线程的终止有两种情况:

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

实例如下:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
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;
}

}