Java多线程——线程的创建方式

社会主义新天地 提交于 2020-12-16 16:02:58

Java多线程——线程的创建方式

摘要:本文主要学习了线程的创建方式,线程的常用属性和方法,以及线程的几个基本状态。

部分内容来自以下博客:

https://www.cnblogs.com/dolphin0520/p/3913517.html

https://www.cnblogs.com/trust-freedom/p/6606594.html

线程的创建

Thread类和Runnable接口

Thread类实现了Runnable接口,实现了Runnable接口里的run()方法。

事实上,查看Thread类的实现源代码会发现Thread类是实现了Runnable接口的。

在Java中,这2种方式都可以用来创建线程去执行子任务,具体选择哪一种方式要看自己的需求。直接继承Thread类的话,可能比实现Runnable接口看起来更加简洁,但是由于Java只允许单继承,所以如果自定义类需要继承其他类,则只能选择实现Runnable接口。

不论哪种方式创建线程,都必须重写run()方法,在run()方法中定义需要执行的任务。

创建好了自己的线程类之后,就可以创建线程对象了,然后通过start()方法去启动线程。注意,不是调用run()方法启动线程,run()方法中只是定义需要执行的任务,如果调用run()方法,即相当于在主线程中执行run()方法,跟普通的方法调用没有任何区别,此时并不会创建一个新的线程来执行定义的任务。

创建线程

在Java中创建线程有两种方法:

◆ 创建继承了Thread类的对象。

 1 public class Demo {
 2     public static void main(String[] args) {
 3         Thread t1 = new DemoThread("线程一");
 4         Thread t2 = new DemoThread("线程二");
 5         t1.start();
 6         t2.start();
 7     }
 8 }
 9 
10 class DemoThread extends Thread {
11     public DemoThread(String name) {
12         this.setName(name);
13     }
14 
15     @Override
16     public void run() {
17         for (int i = 0; i < 100000; i++) {
18             System.out.println(Thread.currentThread().getName() + " >>> " + i);
19         }
20     }
21 }

◆ 创建传入一个实现了Runnable接口的类的Thread对象。

 1 public class Demo {
 2     public static void main(String[] args) {
 3         DemoThread dt = new DemoThread();
 4         Thread t1 = new Thread(dt, "线程一");
 5         Thread t2 = new Thread(dt, "线程二");
 6         t1.start();
 7         t2.start();
 8     }
 9 }
10 
11 class DemoThread implements Runnable {
12     @Override
13     public void run() {
14         for (int i = 0; i < 100000; i++) {
15             System.out.println(Thread.currentThread().getName() + " >>> " + i);
16         }
17     }
18 }

线程的常用属性和方法

属性

priority:线程的优先级。最低为1,最高为10,默认为5。优先级高的线程获取CPU时间片的概率高。

threadStatus:线程的状态。常见的状态有NEW、RUNNABLE、BLOCKED、WAITING。

构造方法

Thread():使用这种方式创建的线程,需要重写Thread类里的run()方法。

Thread(Runnable target):使用这种方式创建的线程,需要实现Runnable接口里的run()方法。

静态方法

Thread.currentThread():获取当前运行的线程。

常用方法

void run():线程执行任务的主要代码。如果没有实现Runnable接口里的run()方法,则需要重写Thread类里的run()方法。

void start():启动线程的方法,虚拟机会调用线程的run()方法。只用调用了start()方法,才会启动一个新的线程执行定义的任务。

void sleep(long millis):本地方法,让当前线程休眠指定时间。sleep()方法不会释放占用的锁。

void join():相当于void join(0),传入0代表一直等待到结束。

void join(long millis):执行指定的线程一段时间,直到执行时间达到传入的时间长度或者线程执行完毕。

线程的状态

NEW:线程刚创建时具有的状态。

1 public static void main(String[] args) {
2     Thread thread = new Thread();
3     System.out.println(thread.getState());
4 }

RUNNABLE:线程正在运行,线程获取CPU的时间片。

1 public static void main(String[] args) {
2     Thread thread = new Thread();
3     thread.start();
4     System.out.println(thread.getState());
5 }

BLOCKED:线程进入阻塞状态。假如有两个都是同步安全的线程,当一个线程处于RUNNABLE状态时,则另一个线程处于BLOCKED状态。

 1 public static void main(String[] args) {
 2     Thread t1 = new Thread() {
 3         public void run() {
 4             synchronized (Object.class) {
 5                 try {
 6                     Thread.sleep(1000);
 7                 } catch (InterruptedException e) {
 8                     e.printStackTrace();
 9                 }
10             }
11         }
12     };
13     Thread t2 = new Thread() {
14         public void run() {
15             synchronized (Object.class) {
16                 try {
17                     Thread.sleep(1000);
18                 } catch (InterruptedException e) {
19                     e.printStackTrace();
20                 }
21             }
22         }
23     };
24     t1.start();
25     t2.start();
26     try {
27         Thread.sleep(100);
28     } catch (Exception e) {
29         e.printStackTrace();
30     }
31     System.out.println(t2.getState());
32 }

WAITTING:程序处于等待状态,调用wait()、join()、await()、lock()等方法,都会使线程处于WAITTING状态,需要注意的是这些方法必须是无参数的。

 1 public static void main(String[] args) {
 2     Thread t = new Thread() {
 3         public void run() {
 4             synchronized (Object.class) {
 5                 try {
 6                     join();
 7                 } catch (InterruptedException e) {
 8                     e.printStackTrace();
 9                 }
10             }
11         }
12     };
13     t.start();
14     try {
15         Thread.sleep(100);
16     } catch (Exception e) {
17         e.printStackTrace();
18     }
19     System.out.println(t.getState());
20 }

TIMED_WAITING:程序处于限时等待状态,调用wait()、join()、await()、lock()、sleep()等方法,都会使线程处于TIMED_WAITING状态,需要注意的是这些方法必须加入参数。

 1 public static void main(String[] args) {
 2     Thread t = new Thread() {
 3         public void run() {
 4             synchronized (Object.class) {
 5                 try {
 6                     Thread.sleep(1000);
 7                 } catch (InterruptedException e) {
 8                     e.printStackTrace();
 9                 }
10             }
11         }
12     };
13     t.start();
14     try {
15         Thread.sleep(100);
16     } catch (Exception e) {
17         e.printStackTrace();
18     }
19     System.out.println(t.getState());
20 }
标签
易学教程内所有资源均来自网络或用户发布的内容,如有违反法律规定的内容欢迎反馈
该文章没有解决你所遇到的问题?点击提问,说说你的问题,让更多的人一起探讨吧!