多线程--多线程的创建方式

Jeroro_franklin

已于 2023-06-28 20:24:39 修改

阅读量43

点赞数

分类专栏： # 多线程文章标签： java

于 2023-06-26 18:10:36 首次发布

本文链接：https://blog.csdn.net/weixin_39213232/article/details/131403057

版权

多线程专栏收录该内容

5 篇文章 0 订阅

订阅专栏

一、线程创建的介绍

1、thread类介绍

Java使用java.lang.Thread类代表线程，所有的线程对象都必须是Thread类或其子类的实例。

每个线程的作用是完成一定的任务，实际上就是执行一段程序流即一段顺序执行的代码。

Java使用线程执行体来代表这段程序流。

2、runabble接口介绍

Thread类有一-个Runnable的父接口，该接口告诉我们可以提供多线程的功能，但是它里面只有一-个run)方法，没有start()方法，所以，即使实现了Runnahle接口。那也无法启动线程，必须依托其他类。而Thread类、有一-个构造方法，参数是Runnable对象，也就是说可以通过Thread类来启动Runnable实现的多线程。所以，实现Runnable接口后，需要使用Thread类来启动。

二、线程的创建方式

1、继承thread类

1.定义Thread类的子类，并重写该类的run)方法，该run()方法的方法体就代表了线程需要完成的任务因此把run()方法
称为线程执行体。
2.创建Thread子类的实例，即创建了线程对象。
3.调用线程对象的start()方法来启动该线程。

1.1、基础版本

两个问题：
a、如果老师把t1.start改成t1.run的话，会出现什么样的结局；
b、为什么主线程的输出会和新创建的线程的输出进行交叉执行；

public class ThreadDemo1 {
	public static void main(String[] args) {
		//创建一个多线程对象
		MyThread t1 = new MyThread("多线程X");//先看看默认的线程名称
		//在创建对象之后，来指定多线程的名称
		t1.setName("多线程A");
		//启动多线程
		t1.start();
		for (int i = 0; i < 10; i++) {
			System.out.println(Thread.currentThread().getName()+"main线程:正在执行"+i);
		}
	}
}
class MyThread extends Thread{
	public MyThread() {
	}
	public MyThread(String name) {
		super(name);
	}
	@Override
	public void run() {
		for (int i = 0; i < 10; i++) {
			System.out.println(this.getName()+":正在执行"+i);
		}
	}
}

使用start方法

mainmain线程:正在执行0
多线程X:正在执行0
多线程X:正在执行1
mainmain线程:正在执行1
多线程X:正在执行2
多线程X:正在执行3
多线程X:正在执行4
多线程X:正在执行5
mainmain线程:正在执行2
多线程X:正在执行6
mainmain线程:正在执行3
mainmain线程:正在执行4
多线程X:正在执行7
多线程X:正在执行8
mainmain线程:正在执行5
多线程X:正在执行9
mainmain线程:正在执行6
mainmain线程:正在执行7
mainmain线程:正在执行8
mainmain线程:正在执行9

public class ThreadDemo1 {
	public static void main(String[] args) {
		//创建一个多线程对象
		MyThread t1 = new MyThread("多线程X");//先看看默认的线程名称
		//如果你调用run方法的话，那么此时不会启动一个新的线程，它这里仅仅只是
		//main方法中的一个普通的方法调用
		t1.run();
		for (int i = 0; i < 10; i++) {
			System.out.println(Thread.currentThread().getName()+"main线程:正在执行"+i);
		}
	}
}
class MyThread extends Thread{
	public MyThread() {
	}
	public MyThread(String name) {
		super(name);
	}
	@Override
	public void run() {
		for (int i = 0; i < 10; i++) {
			System.out.println(this.getName()+":正在执行"+i);
		}
	}
}

使用run()

多线程X:正在执行0
多线程X:正在执行1
多线程X:正在执行2
多线程X:正在执行3
多线程X:正在执行4
多线程X:正在执行5
多线程X:正在执行6
多线程X:正在执行7
多线程X:正在执行8
多线程X:正在执行9
mainmain线程:正在执行0
mainmain线程:正在执行1
mainmain线程:正在执行2
mainmain线程:正在执行3
mainmain线程:正在执行4
mainmain线程:正在执行5
mainmain线程:正在执行6
mainmain线程:正在执行7
mainmain线程:正在执行8
mainmain线程:正在执行9

1.2、匿名内部类版

使用匿名内部类的形式来创建一个多线程对象

public class ThreadDemo2 {
	public static void main(String[] args) {
		//创建一个多线程对象
//		Thread t1 = new Thread("多线程Y") {
//			public void run() {
//				for (int i = 0; i < 10; i++) {
//					System.out.println(this.getName()+":正在执行"+i);
//				}
//			}
//		};//先看看默认的线程名称
//		t1.start();
		//多线程的另外一个简化版本
		new Thread("多线程Y") {
			public void run() {
				for (int i = 0; i < 10; i++) {
					System.out.println(this.getName()+":正在执行"+i);
				}
			}
		}.start();
		for (int i = 0; i < 10; i++) {
			System.out.println(Thread.currentThread().getName()+"main线程:正在执行"+i);
		}
	}
}

2、实现runnable接口

1.定义Runnable类的子类，并重写该类的run()方法，该run()方法的方法体就代表了线程需要完成的任务,因此把run()方
法称为线程执行体。
2.创建Runnable子类的实例。
3.将Runnable接口的子类对象作为参数传递给Thread类的构造函数。
4.调用Thread对象的start()方法来启动该线程。

2.1、基础版

public class RunableDemo1 {
	public static void main(String[] args) {
		//创建一个Runnable的子类对象
		MyThread1 t1 = new MyThread1();
		//创建一个Thread对象，然后把Runnable子类对象放入到Thread的构造函数中
		Thread thread = new Thread(t1,"多线程K");
		//启动多线程
		thread.start();
		for (int i = 0; i < 10; i++) {
			System.out.println(Thread.currentThread().getName()+"main线程:正在执行"+i);
		}
	}
}
class MyThread1 implements Runnable{
	@Override
	public void run() {
		for (int i = 0; i < 10; i++) {
			System.out.println(Thread.currentThread().getName()+":正在执行"+i);
		}
	}
}

2.2、匿名内部类版

使用匿名内部类的形式来通过Runnable来构建一个多线程对象

public class RunableDemo2 {
	public static void main(String[] args) {
		//创建一个Thread对象，然后把Runnable子类对象放入到Thread的构造函数中
//		Thread thread = new Thread(new Runnable() {
//			public void run() {
//				for (int i = 0; i < 10; i++) {
//					System.out.println(Thread.currentThread().getName()+":正在执行"+i);
//				}
//			}
//		},"多线程K");
//		//启动多线程
//		thread.start();
		//简化，不需要变量名
		 new Thread(new Runnable() {
			public void run() {
				for (int i = 0; i < 10; i++) {
					System.out.println(Thread.currentThread().getName()+":正在执行"+i);
				}
			}
		},"多线程J").start();
		for (int i = 0; i < 10; i++) {
			System.out.println(Thread.currentThread().getName()+"main线程:正在执行"+i);
		}
	}
}

三、实现Runnable 比继承Thread更有优势

1、整体概括

1.适合多个相同的程序代码的线程去共享同一个资源。

Thread是多个线程分别完成自己的任务
Runnable是多个线程共同完成一个任务

2.可以避免java中的单继承的局限性。
3.增加程序的健壮性，实现解耦操作，代码可以被多个线程共享，代码和线程独立。
4.线程池只能放入实现Runable或Callable类线程，不能直接放入继承Thread的类。
■线程知识补充
在java中，每次程序运行至少启动2个线程。一个是main线程，一个是垃圾收集线程。因为每当使用java命令执行一
个类的时候，实际上都会启动一个JVM，每一个JVM其实在就是在操作系统中启动了一个进程。

2、代码演示–卖票

请分别使用继承Thread和实现Runnable的方式来模拟一个火车票的卖票场景:假设总票数是10张，我们
需要三个窗口同时来进行卖票。

2.1、thread实现

public class ExtendsThreadDemo {
	public static void main(String[] args) {
		//构建3个Thread1对象，来模拟3个卖票窗口的卖票操作
		Thread1 t1 = new Thread1("窗口A");
		Thread1 t2 = new Thread1("窗口B");
		Thread1 t3 = new Thread1("窗口C");
		t1.start();
		t2.start();
		t3.start();
	}
}
//创建一个Thread的子类，让该线程进行卖票的动作
class Thread1 extends Thread{
	//设置票数为10张
//	private int ticket = 10;
	//运行之后，发现会出现3个完整的10张票的兜售情况，经过分析
	//得出，是因为ticket被每个线程独有所导致的，所以我们把ticket
	//改成static共享资源试试
	static int ticket = 10;
	//设置一个属性为每个线程的名称
	private String name;
	//构造出有名字的构造函数
	public Thread1(String name) {
		this.name = name;
	}
	@Override
	public void run() {
		//设置一个死循环，不断进行卖票的动作
		while(true) {
			//如果票数大于0，那么继续卖票
			if(ticket>0) {
				System.out.println(this.name+"卖了："+this.ticket--+"这张票");
			}else {
				break;
			}
		}
	}
}

2.2、Runnable实现

runnable形式可以让整个类共享

public class ImplementsRunnableDemo {
	public static void main(String[] args) {
		//构建一个Runbale的子类对象
		Thread2 thread = new Thread2();
		//创建多个Thread对象，然后让他们共同使用同一个Runnable对象
		Thread t1 = new Thread(thread,"窗口A");
		Thread t2 = new Thread(thread,"窗口B");
		Thread t3 = new Thread(thread,"窗口C");
		//启动这三个线程
		t1.start();
		t2.start();
		t3.start();
	}
}
class Thread2 implements Runnable{
	//设置票数为10张
	private int ticket = 10;
	@Override
	public void run() {
		//设置一个死循环，不断进行卖票的动作
		while(true) {
			//如果票数大于0，那么继续卖票
			if(ticket>0) {
				System.out.println(Thread.currentThread().getName()+"卖了："+this.ticket--+"这张票");
			}else {
				break;
			}
		}
	}
}

3、两种方式的比较

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-WqmP3r2u-1687773987017)(002-多线程的创建方式.assets/image-20230624185852518.png)]

使用Thread来构建线程的话，相当于是一个线程做一个事情，他们相互之间是独立的，

但是很多时候，我们需要多个线程做一个事情的时候，那么继承thread就无法完成我们的需求，

但是实现Runnable既可以满足一个线程做一个事情的场景，也可以满足多个线程做一个事情的场景!

Jeroro_franklin

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
多线程--多线程的创建方式

Thread类有一-个Runnable的父接口，该接口告诉我们可以提供多线程的功能，但是它里面只有一-个run)方法，没有start()方法，所以，即使实现了Runnahle接口。那也无法启动线程，必须依托其他类。而Thread类、有一-个构造方法，参数是Runnable对象，也就是说可以通过Thread类来启动Runnable实现的多线程。所以，实现Runnable接口后，需要使用Thread类来启动。
复制链接

扫一扫