6. 线程的常用方法
大约 7 分钟
1.start方法
start方法是我们开启一个新的线程的方法，但是并不是直接开启，而是告诉CPU我已经准备好了，快点运行我，这是启动一个线程的唯一入口。
void start()
// 导致此线程开始执行; Java虚拟机调用此线程的run方法。2.run方法
线程的线程体，当一个线程开始运行后，执行的就是run方法里面的代码，我们不能直接通过线程对象来调用run方法。因为这并没有产生一个新的线程。仅仅只是一个普通对象的方法调用。
void run()
// 如果这个线程使用单独的Runnable运行对象构造，则调用该Runnable对象的run方法; 否则，此方法不执行任何操作并返回。3.getName方法
获取线程名称的方法
String getName()
返回此线程的名称。案例代码
package com.bobo.fun;
public class ThreadFunDemo01 {
/**
* 线程中的常用的方法
* @param args
*/
public static void main(String[] args) {
System.out.println(Thread.currentThread().getName() + " main执行了");
Runnable runnable = new MyRunable();
// 创建并启动多个线程
new Thread(runnable).start();
new Thread(runnable).start();
new Thread(runnable).start();
new Thread(runnable).start();
new Thread(runnable).start();
new Thread(runnable).start();
new Thread(runnable).start();
}
}
class MyRunable implements Runnable{
@Override
public void run() {
// Thread.currentThread() 获取当前线程对象
System.out.println(Thread.currentThread().getName() + " 执行了...");
}
}输出结果:
main main执行了
Thread-0 执行了...
Thread-1 执行了...
Thread-3 执行了...
Thread-2 执行了...
Thread-4 执行了...
Thread-5 执行了...
Thread-6 执行了... 默认的主方法的线程名称是 main,而其他子线程的名称默认的是 Thread-编号，我们不难发现默认的线程名称的识别度不高，那么我们是否可以自定义线程名称呢？显然是可以的
继承Thread类
package com.bobo.fun;
public class ThreadFunDemo02{
/**
* 线程中的常用的方法
* @param args
*/
public static void main(String[] args) {
System.out.println(Thread.currentThread().getName() + " main执行了");
// 创建并启动多个线程
Thread t1 = new MyThread01("线程A");
t1.start();
Thread t2 = new MyThread01("线程B");
t2.start();
Thread t3 = new MyThread01("线程C");
t3.start();
}
}
class MyThread01 extends Thread{
public MyThread01(String threadName){
// 指定线程的名称
super(threadName);
}
@Override
public void run() {
System.out.println(this.getName() + " 执行了...");
}
}输出结果：
main main执行了
线程A 执行了...
线程B 执行了...
线程C 执行了...实现Runable接口，本质还是Thread有参的构造方法实现的名称重命名
package com.bobo.fun;
public class ThreadFunDemo03 {
public static void main(String[] args) {
Runnable runnable = new MyRunable01();
// 重命名 线程的名称
Thread t1 = new Thread(runnable,"线程I");
t1.start();
Thread t2 = new Thread(runnable,"线程II");
t2.start();
Thread t3 = new Thread(runnable,"线程III");
t3.start();
}
}
class MyRunable01 implements Runnable{
@Override
public void run() {
System.out.println(Thread.currentThread().getName() + " 执行了...");
}
}输出结果
线程III 执行了...
线程II 执行了...
线程I 执行了...4.优先级
我们创建的多个线程的执行顺序是由CPU决定的。Java中提供了一个线程调度器来监控程序中启动后进入就绪状态的所有的线程，优先级高的线程会获取到比较多运行机会
/**
* 最小的优先级是 1
*/
public final static int MIN_PRIORITY = 1;
/**
* 默认的优先级都是5
*/
public final static int NORM_PRIORITY = 5;
/**
* 最大的优先级是10
*/
public final static int MAX_PRIORITY = 10;案例代码
package com.bobo.fun;
public class ThreadDemo05 {
/**
* 线程的优先级
* @param args
*/
public static void main(String[] args) {
Runnable runnable = new MyRunable02();
for(int i = 1 ; i <= 10 ; i ++){
Thread t1 = new Thread(runnable,"" + i);
t1.setPriority(i); // 设置优先级大小
t1.start();
}
}
}
class MyRunable02 implements Runnable{
@Override
public void run() {
System.out.println(Thread.currentThread().getName()+" 执行了 优先级：" + Thread.currentThread().getPriority());
}
}输出结果：
1 执行了 优先级：1
4 执行了 优先级：4
3 执行了 优先级：3
2 执行了 优先级：2
6 执行了 优先级：6
5 执行了 优先级：5
7 执行了 优先级：7
8 执行了 优先级：8
9 执行了 优先级：9
10 执行了 优先级：10 大家会发现，设置了优先级后输出的结果和我们预期的并不一样，这是为什么呢？优先级在CPU调动线程执行的时候会是一个参考因数，但不是决定因数，
5.sleep方法
将当前线程暂定指定的时间，
static void sleep(long millis)
// 使当前正在执行的线程以指定的毫秒数暂停（暂时停止执行），具体取决于系统定时器和调度程序的精度和准确性。演示案例
package com.bobo.fun;
public class ThreadFunDemo06 {
/**
* sleep 方法
* 休眠
* @param args
*/
public static void main(String[] args) throws Exception{
System.out.println("main ... start");
Thread.sleep(1000);
Runnable runnable = new MyRunable03();
new Thread(runnable).start();
Thread.sleep(1000);
System.out.println("main .... end ");
}
}
class MyRunable03 implements Runnable{
@Override
public void run() {
for (int i = 1 ; i < 50 ; i ++){
// 每循环一次 休眠 100毫秒
try {
// 将当前线程休眠指定的时间
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName() + " :" + i);
}
}
}课堂案例：
练习1：设计一个线程类：创建3个子线程，每个线程分别打印数字，分别睡100,200,300
package com.bobo.fundemo;
public class FunDemo01 {
/**
* 练习1：设计一个线程类：创建3个子线程，每个线程分别打印数字，分别睡100,200,300
* @param args
*/
public static void main(String[] args) {
new Thread(new MyRunable01(100),"A").start();
new Thread(new MyRunable01(200),"B").start();
new Thread(new MyRunable01(300),"C").start();
}
}
class MyRunable01 implements Runnable{
private int sleepTime;
public MyRunable01(int sleepTime){
this.sleepTime = sleepTime;
}
@Override
public void run() {
for(int i = 0 ; i < 10; i ++){
System.out.println(Thread.currentThread().getName() + " :" + i);
// 休眠指定的时间
try {
Thread.sleep(sleepTime);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}输出结果：
A :0
B :0
C :0
A :1
B :1
A :2
C :1
A :3
B :2
A :4
A :5
C :2
B :3
A :6
A :7
B :4
A :8
C :3
A :9
B :5
C :4
B :6
B :7
C :5
B :8
C :6
B :9
C :7
C :8
C :9练习2：设计一个线程：运行10秒后被终止(掌握线程的终止方法)
package com.bobo.fundemo;
import java.util.Date;
public class FunDemo02 {
/**
* 练习2：设计一个线程：运行10秒后被终止(掌握线程的终止方法)
* @param args
*/
public static void main(String[] args) throws Exception{
MyRunable02 runnable = new MyRunable02();
new Thread(runnable).start();
Thread.sleep(10000); // 主线程休眠10秒钟
runnable.flag = false;
System.out.println("main、 end ...");
}
}
class MyRunable02 implements Runnable{
boolean flag = true;
@Override
public void run() {
while(flag){
try {
Thread.sleep(1000);
System.out.println(new Date());
} catch (InterruptedException e) {
e.printStackTrace();
}
}
System.out.println(Thread.currentThread().getName() + " 执行完成");
}
}练习3：设计一个线程类，启动2个子线程，一个子线程每打印10个数字睡眠，另一个线程每打印20个睡眠。。
package com.bobo.fundemo;
public class FunDemo03 {
/**
* 练习3：设计一个线程类，启动2个子线程，一个子线程每打印10个数字睡眠，另一个线程每打印20个睡眠。。
* @param args
*/
public static void main(String[] args) {
new Thread(new MyRunableO3(),"A").start();
new Thread(new MyRunableO3(),"B").start();
}
}
class MyRunableO3 implements Runnable{
private int i = 0;
@Override
public void run() {
String name = Thread.currentThread().getName();
while (i < 1000){
if("A".equals(name)){
if(i % 10==0 && i != 0){
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}else if("B".equals(name)){
if(i%20 ==0 && i!= 0){
try {
Thread.sleep(2000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
System.out.println(name + "\t" + i++);
}
}
}6.isAlive
获取线程的状态。
package com.bobo.fundemo;
public class FunDemo04 {
/**
* isAlive方法
* @param args
*/
public static void main(String[] args) {
System.out.println("main start ...");
Thread t1 = new Thread(new Runnable() {
@Override
public void run() {
System.out.println(Thread.currentThread().getName() + " .... ");
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
});
System.out.println("线程的状态："+t1.isAlive());
t1.start();
System.out.println("线程的状态："+t1.isAlive());
System.out.println("main end ...");
}
}输出结果
main start ...
线程的状态：false
线程的状态：true
main end ...
Thread-0 ....7.join
调用某线程的该方法，将当前线程和该线程合并，即等待该线程结束，在恢复当前线程的运行
package com.bobo.fundemo;
public class FunDemo05 {
/**
* 线程的合并
* join方法
* @param args
*/
public static void main(String[] args) {
System.out.println("main start ...");
Thread t1 = new Thread(new Runnable() {
@Override
public void run() {
for(int i = 0 ; i < 10; i++){
System.out.println(Thread.currentThread().getName() + " 子线程执行了...");
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
});
t1.start();
try {
t1.join(); // 线程的合并，和主线程合并 相当于我们直接调用了run方法
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("main end ...");
}
}输出结果：
main start ...
Thread-0 子线程执行了...
Thread-0 子线程执行了...
Thread-0 子线程执行了...
Thread-0 子线程执行了...
Thread-0 子线程执行了...
Thread-0 子线程执行了...
Thread-0 子线程执行了...
Thread-0 子线程执行了...
Thread-0 子线程执行了...
Thread-0 子线程执行了...
main end ...8.yield
让出CPU，当前线程进入就绪状态
package com.bobo.fundemo;
public class FuneDemo06 extends Thread{
public FuneDemo06(String threadName){
super(threadName);
}
/**
* yield方法 礼让
*
* @param args
*/
public static void main(String[] args) {
FuneDemo06 f1 = new FuneDemo06("A1");
FuneDemo06 f2 = new FuneDemo06("A2");
FuneDemo06 f3 = new FuneDemo06("A3");
f1.start();
f2.start();
f3.start();
}
@Override
public void run() {
for(int i = 0 ; i < 100; i ++){
try {
Thread.sleep(10);
} catch (InterruptedException e) {
e.printStackTrace();
}
if(i%10 == 0 && i != 0){
System.out.println(Thread.currentThread().getName()+" 礼让：" + i);
Thread.currentThread().yield(); // 让出CPU
}else{
System.out.println(this.getName() + ":" + i);
}
}
}
}9.wait和notify/notifyAll
阻塞和唤醒的方法，是Object中的方法，我们在数据同步的时候会介绍到