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

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

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

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

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

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

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

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

代码如下:

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. 便于共享资源

实现过程如下:

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.线程的终止

线程的终止有两种情况:

  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;
	}
	
}

posted @ 2019-02-13 11:32  DLKKILL  阅读(693)  评论(0编辑  收藏  举报