说明 | |
---|---|
void run() | 在线程开启后,此方法将被调用执行 |
void start() |
-
定义一个类MyThread继承Thread类
-
在MyThread类中重写run()方法
-
创建MyThread类的对象
-
package ThreadDemo;
class MyThread extends Thread {
@Override
public void run() { // run()是用来封装被线程执行的代码;
for (int i = 0; i < 100; i++) {
System.out.println(i);
}
}
}
public class TreadDemo1 {
public static void main(String[] args) {
MyThread my1 = new MyThread();
MyThread my2 = new MyThread();
// my1.run();封装线程执行的代码,直接调用,相当于普通方法的调用
// my2.run();
//void start() 导致此线程开始执行; Java虚拟机调用此线程的run方法
my1.start(); // 启动线程;然后由JVM调用此线程的run()方法
my2.start();
}
}
-
为什么要重写run()方法?
因为run()是用来封装被线程执行的代码
-
run()方法和start()方法的区别?
run():封装线程执行的代码,直接调用,相当于普通方法的调用
Thread构造方法
说明 | |
---|---|
Thread (Runnable target) | 分配一个新的Thread对象 |
Thread (Runnable target, String name) |
-
定义一个类MyRunnable实现Runnable接口
-
在MyRunnable类中重写run()方法
-
创建MyRunnable类的对象
-
创建Thread类的对象,把MyRunnable对象作为构造方法的参数
-
package ThreadDemo;
// Runnable接口应该被任何类的实例的目的是通过一个线程执行的实施。
// 类必须定义一个称为 run此接口旨在为那些希望在它们活动时执行代码的对象提供一个通用的协议。
// 例如,Runnable通过类Thread实施。激活的意思是说一个线程已启动并且尚未停止。
class MyRunnable implements Runnable {
@Override
public void run() {
for(int i=0; i<100; i++) {
// Thread.currentThread().getName():
// currentThread()返回当前正在执行的线程对象的引用。
// getName()返回此线程的名称。setName()改变该线程的名称等于参数 name
System.out.println(Thread.currentThread().getName()+":"+i);
}
}
}
public class TreadDemo2 {
public static void main(String[] args) {
//创建MyRunnable类的对象
MyRunnable my = new MyRunnable();
//创建Thread类的对象,把MyRunnable对象作为构造方法的参数
//Thread(Runnable target)
// Thread t1 = new Thread(my);
// Thread t2 = new Thread(my);
//Thread(Runnable target, String name)
Thread t1 = new Thread(my,"坦克");
Thread t2 = new Thread(my,"飞机");
//启动线程
t1.start();
t2.start();
}
}
说明 | |
---|---|
V call() | 计算结果,如果无法计算结果,则抛出一个异常 |
FutureTask(Callable<V> callable) | 创建一个 FutureTask,一旦运行就执行给定的 Callable |
V get() |
-
定义一个类MyCallable实现Callable接口
-
在MyCallable类中重写call()方法
-
创建MyCallable类的对象
-
创建Future的实现类FutureTask对象,把MyCallable对象作为构造方法的参数
-
创建Thread类的对象,把FutureTask对象作为构造方法的参数
-
启动线程
-
package ThreadDemo;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;
class MyCallable implements Callable<String> {
@Override
public String call() throws Exception{ // 计算结果,如果无法计算结果,则抛出一个异常
for (int i = 0; i < 100; i++) {
System.out.println("去表白了:" + i);
}
//返回值就表示线程运行完毕之后的结果
return "答应了";
}
}
public class TreadDemo3 {
public static void main(String[] args) throws ExecutionException, InterruptedException {
//线程开启之后需要执行里面的call方法
MyCallable mc = new MyCallable();
// Thread t1 = new Thread(mc); 这样不行,所以引入一个 FutureTask 这个方法;泛型为返回的数据类型
//可以获取线程执行完毕之后的结果.也可以作为参数传递给Thread对象
FutureTask<String> ft = new FutureTask<>(mc);
//创建线程对象
Thread t1 = new Thread(ft);
t1.start();
String s = ft.get(); // 等待,如果需要计算完成,然后检索其结果。 【 返回的return 】
//开启线程
//String s = ft.get();
System.out.println(s);
}
}
-
实现Runnable、Callable接口
-
好处: 扩展性强,实现该接口的同时还可以继承其他的类
-
缺点: 编程相对复杂,不能直接使用Thread类中的方法
-
-
继承Thread类
-
好处: 编程比较简单,可以直接使用Thread类中的方法
-
-
说明 | |
---|---|
void setName(String name) | 将此线程的名称更改为等于参数name |
String getName() | 返回此线程的名称 |
Thread currentThread() |
package ThreadDemo;
class MyThread1 extends Thread {
public MyThread1() {
// 空参构造
}
public MyThread1(String name) {
super(name); // 有参构造;调用父类 有参构造
}
@Override
public void run() {
for (int i = 0; i < 100; i++) {
System.out.println(getName()+":"+i);
}
}
}
public class TreadDemo4 {
public static void main(String[] args) {
MyThread1 my1 = new MyThread1();
MyThread1 my2 = new MyThread1();
//void setName(String name):将此线程的名称更改为等于参数 name
my1.setName("高铁");
my2.setName("飞机");
//Thread(String name)
MyThread1 my11 = new MyThread1("高铁");
MyThread1 my21 = new MyThread1("飞机");
my1.start();
my2.start();
my11.start();
my21.start();
//static Thread currentThread() 返回对当前正在执行的线程对象的引用
System.out.println(Thread.currentThread().getName());
}
}
方法名 | 说明 |
---|---|
static void sleep(long millis) |
package ThreadDemo;
class MyRunnable1 implements Runnable {
@Override
public void run() {
for (int i = 0; i < 100; i++) {
try {
Thread.sleep(3000); // 睡眠3秒;当前正在执行的线程休眠(暂停执行)为指定的毫秒数,根据精度和系统定时器和调度的准确性。
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName() + "---" + i);
}
}
}
public class TreadDemo5 {
public static void main(String[] args) throws InterruptedException {
/*
System.out.println("睡觉前");
Thread.sleep(3000);
System.out.println("睡醒了");
*/
MyRunnable1 mr = new MyRunnable1();
Thread t1 = new Thread(mr);
Thread t2 = new Thread(mr);
t1.start();
t2.start();
}
}
-
两种调度方式
-
分时调度模型:所有线程轮流使用 CPU 的使用权,平均分配每个线程占用 CPU 的时间片
-
抢占式调度模型:优先让优先级高的线程使用 CPU,如果线程的优先级相同,那么会随机选择一个,优先级高的线程获取的 CPU 时间片相对多一些
-
-
Java使用的是抢占式调度模型
-
随机性
说明 | |
---|---|
final int getPriority() | 返回此线程的优先级 |
final void setPriority(int newPriority) |
package ThreadDemo;
import java.util.concurrent.Callable;
import java.util.concurrent.FutureTask;
class MyCallable2 implements Callable<String> {
@Override
public String call() throws Exception {
for (int i = 0; i < 100; i++) {
System.out.println(Thread.currentThread().getName() + "---" + i);
}
return "线程执行完毕了";
}
}
public class TreadDemo6 {
public static void main(String[] args) {
//优先级: 1 - 10 默认值:5
MyCallable2 mc = new MyCallable2();
FutureTask<String> ft = new FutureTask<>(mc);
Thread t1 = new Thread(ft);
t1.setName("飞机");
t1.setPriority(10);
//System.out.println(t1.getPriority());//10 默认为5
t1.start();
MyCallable2 mc2 = new MyCallable2();
FutureTask<String> ft2 = new FutureTask<>(mc2);
Thread t2 = new Thread(ft2);
t2.setName("坦克");
t2.setPriority(1);
//System.out.println(t2.getPriority());//1;默认为5
t2.start();
System.out.println("第一个线程的优先级:"+ t1.getPriority());// 10
System.out.println("第二个线程的优先级:"+ t2.getPriority());//1
}
}
说明 | |
---|---|
void setDaemon(boolean on) |
public class MyThread1 extends Thread {
@Override
public void run() {
for (int i = 0; i < 10; i++) {
System.out.println(getName() + "---" + i);
}
}
}
public class MyThread2 extends Thread {
@Override
public void run() {
for (int i = 0; i < 100; i++) {
System.out.println(getName() + "---" + i);
}
}
}
public class Demo {
public static void main(String[] args) {
MyThread1 t1 = new MyThread1();
MyThread2 t2 = new MyThread2();
t1.setName("女神");
t2.setName("备胎");
//把第二个线程设置为守护线程
//当普通线程执行完之后,那么守护线程也没有继续运行下去的必要了.
t2.setDaemon(true);
t1.start();
t2.start();
}
}