23.多线程

一.多线程的实现:

• 继承Thread类
• 实现Runnable接口

---

1.继承Thread类

继承自Thread类,Thread类是所有线程的父类,实现了对线程的抽取和封装

创建并启动多线程的步骤:

• 1)定义一个类，继承自Thread类，并重写该类的run()方法，该run方法的方法体就代表了线程需要完成的任务，因此，run方法的方法体被称为线程执行体
• 2)创建Thread子类的对象，即创建了子线程
• 3)用线程对象的start()方法来启动该线程

		//创建子线程
		MyThread mt=new MyThread();
		//设置线程的名字
		mt.setName("子线程1");
		//mt.start();

//新建立的任务
public class MyThread extends Thread {
	//重写run方法,在run方法中编写要执行的循环任务
	public void run(){
		//获取当前执行的线程
		Thread t=Thread.currentThread();
		for(int j=0;j<1000; j++){
			System.out.println(t.getName()+",j="+j);
		}
	}
}

2.实现Runnable接口

步骤:

• 1)定义一个Runnable接口的实现类，并重写该接口中的run方法，该run方法的方法体同样是该线程的线程执行体
• 2)创建Runnable实现类的实例，并以此实例作为Thread的target来创建Thread对象，该Thread对象才是真正的线程对象
• 3)调用线程对象的start方法来启动该线程

//实现Runnable接口
		MyThread3 t3=new MyThread3();
		Thread tt1=new Thread(t3);
		tt1.start();
		Thread tt2=new Thread(t3);
		tt2.start();

public class MyThread3 implements Runnable {
	@Override
	public void run() {
		// TODO Auto-generated method stub
		for(int i=0; i<10; i++){
			System.out.println(i);
		}
	}
}

使用匿名内部类的方式创建线程类(不常用):

public class Demo2 {
	//使用匿名内部类的方式来创建线程类，实现Runnable
	static Runnable r=new Runnable() {		
		@Override
		public void run() {
			// TODO Auto-generated method stub
			String name=Thread.currentThread().getName();
			for(int i=0; i<10; i++){
				System.out.println(name+",i="+i);
				//当i=5时，让线程停止/阻塞  sleep
				if(i==5){
					try {
						Thread.sleep(3000);
					} catch (InterruptedException e) {
						// TODO Auto-generated catch block
						e.printStackTrace();
					}
				}
			}
		}
	};
	public static void main(String[] args) {
		//设置线程的优先级别：优先级别高的线程，执行机会高
		Thread t=new Thread(r);
		t.setName("线程1：");
		t.setPriority(6);
		t.start();
		
		Thread t2=new Thread(r);
		t2.setName("线程2：");
		t2.setPriority(9);
		t2.start();
	}
}

3.两种实现方式的比较

继承Thread类的方式:

• 1).编写简单，如果要访问当前线程，除了可以通过Thread.currentThread()方式之外，还可以使用super关键字
• 2)弊端：因为线程类已经继承了Thread类，则不能再继承其他类【单继承】

实现Runnable接口的方式:

• 1)线程类只是实现了Runnable接口，还可以继承其他类【一个类在实现接口的同时还可以继承另外一个类】
• 2)可以多个线程共享同一个target对象，所以非常适合多个线程来处理同一份资源的情况
• 3)弊端：编程稍微复杂，不直观，如果要访问当前线程，必须使用Thread.currentThread()

4.调用start()与run()方法的区别(重点!!!)

• 当调用start()方法时将创建新的线程，并且执行run()方法里的代码
• 但是如果直接调用run()方法，不会创建新的线程也不会执行调用线程的代码