一 、线程创建的介绍
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、两种方式的比较
使用Thread来构建线程的话,相当于是一个线程做一个事情
,他们相互之间是独立的,
但是很多时候,我们需要多个线程做一个事情的时候,那么继承thread就无法完成我们的需求,
但是实现Runnable既可以满足一个线程做一个事情的场景,也可以满足多个线程做一个事情的场景!