多线程的实现方式：
- 继承Thread类
- 实现Runnable接口
方式一：继承Thread类
- 定义一个类MyThread继承Thread类
- 在MyThread类中重写run方法
- 创建MyThread类的对象
- 启动线程
下面看一段代码：
MyThread重写run方法，输出0-99
public class MyThread extends Thread {
@Override
public void run() {
for(int i=0;i<100;i++){
System.out.println(getName()+":"+i);
}
}
}
main类：
public class ThreadDemo01 {
public static void main(String[] args) {
MyThread m1=new MyThread();
MyThread m2=new MyThread();
//m1.run();
//m2.run();
//void start() 导致此线程开始执行；JAVA虚拟机调用此线程的run方法
m1.start();
m2.start();
}
}
设置和获取线程名称
Thread类中设置和获取线程名称的方法
- void setName(String name):将此线程的名称更改为等于参数name
- String getName():返回此线程的名称
- static Thread currentThread() ：获取main方法线程名称
下边代码是线程的无参构造，带参构造
MyThread类：
public class MyThread extends Thread {
public MyThread() {
}//无参构造
public MyThread(String name) {
//带参构造
super(name);
}
@Override
public void run() {
for(int i=0;i<100;i++){
System.out.println(getName()+":"+i);
}
}
}
main类
public class ThreadDemo {
public static void main(String[] args) {
/* MyThread m1=new MyThread();//无参构造
MyThread m2=new MyThread();
//m1.run();
//m2.run();
m1.setName("苹果");
m2.setName("香蕉");
//void start() 导致此线程开始执行；
//JAVA虚拟机调用此线程的run方法
*/
//Thread(String name)
MyThread m1=new MyThread("苹果");//带参构造
MyThread m2=new MyThread("香蕉");
m1.start();
m2.start();
//获取main方法线程名称
//static Thread currentThread() 返回对当前正在执行的线程对象的引用
//System.out.println(Thread.currentThread());
}
}
线程调度
线程有两种调度模型
- 分时调度模型:所有线程轮流使用CPU的使用权，
平均分配每个线程占用CPU的时间片 - 抢占式调度模型:优先让优先级高的线程使用CPU,如果线程的优先级相同,那么会随机选择一个, 优先级高的线程获取的CPU时间片相对多-些
-
Java使用的是抢占式调度模型
-
假如计算机只有一个CPU,那么CPU在某个时刻只能执行条指令,
线程只有得到CPU时间片,也就是使用权,才可以执行指令。
所以说多线程程序的执行是有随机性,因为谁抢到CPU的使用权是不一定的
Thread类中设置和获取线程优先级的方法
- public final int getPriority():返回此线程的优先级
- public final void setPriority(int newPriority):更改此线程的优先级
看段代码：
MyThread类：
public class MyThread extends Thread {
@Override
public void run() {
for(int i=0;i<100;i++){
System.out.println(getName()+":"+i);
}
}
}
main类：
import 多线程.MyThread;
public class ThreadDemo {
public static void main(String[] args) {
MyThread m1=new MyThread();
MyThread m2=new MyThread();
MyThread m3=new MyThread();
m1.setName("苹果");
m2.setName("西瓜");
m3.setName("菠萝");
//public final int getPriority():返回此线程的优先级
// System.out.println(m1.getPriority());//5
// System.out.println(m2.getPriority());//5
// System.out.println(m3.getPriority());//5
//public final void setPriority(int newPriority):更改此线程的优先级
// System.out.println(Thread.MAX_PRIORITY);//10
// System.out.println(Thread.MIN_PRIORITY);//1
// System.out.println(Thread.NORM_PRIORITY);//5 默认
m1.setPriority(5);
m2.setPriority(10);
m3.setPriority(1);
m1.start();
m2.start();
m3.start();
}
}
线程常用三个方法
-
static void sleep(long millis)使当前正在执行的线程停留 (暂停执行)指定的毫秒数
-
void join():等待这个线程死亡
-
void setDaemon(booleanon)将此线程标记为守护线程， 当运行的线程都是守护线程时，Java虚拟机将退出
方式2:实现Runnable接口
- 定义一个类MyRunnable实现Runnable接口
- 在MyRunnable类中重写run()方法
- 创建MyRunnable类的对象
- 创建Thread类的对象，把MyRunnable对象作为构造方法的参数
- 启动线程
代码：
MyRunnable类：
public class MyRunnable implements Runnable {
@Override
public void run() {
for(int i=0;i<100;i++){
System.out.println(Thread.currentThread().getName()+":"+i);
}
}
}
main类：
public class MyRunnableDemo {
public static void main(String[] args) {
//创建MyRunnable类的对象
MyRunnable m=new MyRunnable();
//创建Thread类的对象，把MyRunnable对象作为构造方法的参数
//Thread (Runnable target)
//Thread t1=new Thread(m);
//Thread t2=new Thread(m);
//Thread (Runnable target,String name)传递对象并设置名字
Thread t1=new Thread(m,"高铁");
Thread t2=new Thread(m,"飞机");
t1.start();
t2.start();
}
}
相比继承Thread类，实现Runnable接口的好处
- 避免了Java单继承的局限性
- 适合多 个相同程序的代码去处理同一个资源的情况，把线程和程序的代码、数据有效分离,较好的体现了面向対象的设计思想