java线程的常用方法

java线程的常用方法

编号 方法 说明
1 public void start() 使该线程开始执行；Java 虚拟机调用该线程的 run 方法。
2 public void run() 如果该线程是使用独立的 Runnable 运行对象构造的，则调用该 Runnable 对象的 run 方法；否则，该方法不执行任何操作并返回。
3 public final void setName(String name) 改变线程名称，使之与参数 name 相同。
4 public final void setPriority(int priority) 更改线程的优先级。
5 public final void setDaemon(boolean on) 将该线程标记为守护线程或用户线程。
6 public final void join(long millisec) 等待该线程终止的时间最长为 millis 毫秒。
7 public void interrupt() 中断线程。
8 public final boolean isAlive() 测试线程是否处于活动状态。
9 public static void yield() 暂停当前正在执行的线程对象，并执行其他线程。
10 public static void sleep(long millisec) 在指定的毫秒数内让当前正在执行的线程休眠（暂停执行），此操作受到系统计时器和调度程序精度和准确性的影响。
11 public static Thread currentThread() 返回对当前正在执行的线程对象的引用。

一：静态方法

（1）currentThread()方法

currentThread()方法可以返回代码段正在被哪个线程调用的信息。


1

2

3

4

5

public class Run1{

    public static void main(String[] args){                

    System.out.println(Thread.currentThread().getName());

    }

}

（2）sleep()方法

方法sleep()的作用是在指定的毫秒数内让当前“正在执行的线程”休眠（暂停执行）。这个“正在执行的线程”是指this.currentThread()返回的线程。

sleep方法有两个重载版本：


1

2

sleep(long millis)     //参数为毫秒

sleep(long millis,int nanoseconds)    //第一参数为毫秒，第二个参数为纳秒

sleep相当于让线程睡眠，交出CPU，让CPU去执行其他的任务。

但是有一点要非常注意，sleep方法不会释放锁，也就是说如果当前线程持有对某个对象的锁，则即使调用sleep方法，其他线程也无法访问这个对象。看下面这个例子就清楚了：


1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

public class Test {

    private int i = 10;

    private Object object = new Object();

    public static void main(String[] args) throws IOException  {

        Test test = new Test();

        MyThread thread1 = test.new MyThread();

        MyThread thread2 = test.new MyThread();

        thread1.start();

        thread2.start();

    }

    class MyThread extends Thread{

        @Override

        public void run() {

            synchronized (object) {

                i++;

                System.out.println("i:"+i);

                try {

                    System.out.println("线程"+Thread.currentThread().getName()+"进入睡眠状态");

                    Thread.currentThread().sleep(10000);

                } catch (InterruptedException e) {

                    // TODO: handle exception

                }

                System.out.println("线程"+Thread.currentThread().getName()+"睡眠结束");

                i++;

                System.out.println("i:"+i);

            }

        }

    }

}

输出结果：

从上面输出结果可以看出，当Thread-0进入睡眠状态之后，Thread-1并没有去执行具体的任务。只有当Thread-0执行完之后，此时Thread-0释放了对象锁，Thread-1才开始执行。

注意，如果调用了sleep方法，必须捕获InterruptedException异常或者将该异常向上层抛出。当线程睡眠时间满后，不一定会立即得到执行，因为此时可能CPU正在执行其他的任务。所以说调用sleep方法相当于让线程进入阻塞状态。

（3）yield()方法

调用yield方法会让当前线程交出CPU权限，让CPU去执行其他的线程。它跟sleep方法类似，同样不会释放锁。但是yield不能控制具体的交出CPU的时间，另外，yield方法只能让拥有相同优先级的线程有获取CPU执行时间的机会。

注意，调用yield方法并不会让线程进入阻塞状态，而是让线程重回就绪状态，它只需要等待重新获取CPU执行时间，这一点是和sleep方法不一样的。

代码：


1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

public class MyThread  extends Thread{

    @Override

    public void run() {

        long beginTime=System.currentTimeMillis();

        int count=0;

        for (int i=0;i<50000000;i++){

            count=count+(i+1);

            //Thread.yield();

        }

        long endTime=System.currentTimeMillis();

        System.out.println("用时："+(endTime-beginTime)+" 毫秒！");

    }

}

public class Run {

    public static void main(String[] args) {

        MyThread t= new MyThread();

        t.start();

    }

}

执行结果：


1

用时：3 毫秒！

如果将 //Thread.yield();的注释去掉，执行结果如下：


1

用时：16080 毫秒！

二：对象方法

（1）start()方法

start()用来启动一个线程，当调用start方法后，系统才会开启一个新的线程来执行用户定义的子任务，在这个过程中，会为相应的线程分配需要的资源。

（2）run()方法

run()方法是不需要用户来调用的，当通过start方法启动一个线程之后，当线程获得了CPU执行时间，便进入run方法体去执行具体的任务。注意，继承Thread类必须重写run方法，在run方法中定义具体要执行的任务。

（3）getId()

getId()的作用是取得线程的唯一标识

代码：


1

2

3

4

5

6

public class Test {

    public static void main(String[] args) {

        Thread t= Thread.currentThread();

        System.out.println(t.getName()+" "+t.getId());

    }

}

输出：


1

main 1

（4）isAlive()方法

方法isAlive()的功能是判断当前线程是否处于活动状态

代码：


1

2

3

4

5

6

7

8

9

10

11

12

13

14

public class MyThread  extends Thread{

    @Override

    public void run() {

        System.out.println("run="+this.isAlive());

    }

}

public class RunTest {

    public static void main(String[] args) throws InterruptedException {

        MyThread myThread=new MyThread();

        System.out.println("begin =="+myThread.isAlive());

        myThread.start();

        System.out.println("end =="+myThread.isAlive());

    }

}

程序运行结果：


1

2

3

begin ==false

run=true

end ==false

方法isAlive()的作用是测试线程是否偶处于活动状态。什么是活动状态呢？活动状态就是线程已经启动且尚未终止。线程处于正在运行或准备开始运行的状态，就认为线程是“存活”的。

有个需要注意的地方


1

System.out.println("end =="+myThread.isAlive());

虽然上面的实例中打印的值是true,但此值是不确定的。打印true值是因为myThread线程还未执行完毕，所以输出true。如果代码改成下面这样，加了个sleep休眠：


1

2

3

4

5

6

7

public static void main(String[] args) throws InterruptedException {

        MyThread myThread=new MyThread();

        System.out.println("begin =="+myThread.isAlive());

        myThread.start();

        Thread.sleep(1000);

        System.out.println("end =="+myThread.isAlive());

    }

则上述代码运行的结果输出为false,因为mythread对象已经在1秒之内执行完毕。

（5）join()方法

在很多情况下，主线程创建并启动了线程，如果子线程中药进行大量耗时运算，主线程往往将早于子线程结束之前结束。这时，如果主线程想等待子线程执行完成之后再结束，比如子线程处理一个数据，主线程要取得这个数据中的值，就要用到join()方法了。方法join()的作用是等待线程对象销毁。


1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

public class Thread4 extends Thread{

    public Thread4(String name) {

        super(name);

    }

    public void run() {

        for (int i = 0; i < 5; i++) {

            System.out.println(getName() + "  " + i);

        }

    }

    public static void main(String[] args) throws InterruptedException {

        // 启动子进程

        new Thread4("new thread").start();

        for (int i = 0; i < 10; i++) {

            if (i == 5) {

                Thread4 th = new Thread4("joined thread");

                th.start();

                th.join();

            }

            System.out.println(Thread.currentThread().getName() + "  " + i);

        }

    }

}

执行结果：


1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

main  0

main  1

main  2

main  3

main  4

new thread  0

new thread  1

new thread  2

new thread  3

new thread  4

joined thread  0

joined thread  1

joined thread  2

joined thread  3

joined thread  4

main  5

main  6

main  7

main  8

main  9

由上可以看出main主线程等待joined thread线程先执行完了才结束的。如果把th.join()这行注释掉，运行结果如下：


1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

main  0

main  1

main  2

main  3

main  4

main  5

main  6

main  7

main  8

main  9

new thread  0

new thread  1

new thread  2

new thread  3

new thread  4

joined thread  0

joined thread  1

joined thread  2

joined thread  3

joined thread  4

（6）getName和setName

用来得到或者设置线程名称。

（7）getPriority和setPriority

用来获取和设置线程优先级。

（8）setDaemon和isDaemon

用来设置线程是否成为守护线程和判断线程是否是守护线程。

守护线程和用户线程的区别在于：守护线程依赖于创建它的线程，而用户线程则不依赖。举个简单的例子：如果在main线程中创建了一个守护线程，当main方法运行完毕之后，守护线程也会随着消亡。而用户线程则不会，用户线程会一直运行直到其运行完毕。在JVM中，像垃圾收集器线程就是守护线程。

在上面已经说到了Thread类中的大部分方法，那么Thread类中的方法调用到底会引起线程状态发生怎样的变化呢？下面一幅图就是在上面的图上进行改进而来的：

原文地址：https://www.cnblogs.com/tutubaobao/p/10050169.html

时间： 2024-10-13 07:29:49

java线程的常用方法的相关文章

Java之线程，常用方法，线程同步，死锁

1, 线程的概念 进程与线程 进程:每个进程都有独立的代码和数据空间(进程上下文),进程间的切换会有较大的开销,一个进程包含1--n个线程.(进程是资源分配的最小单位) 线程:同一类线程共享代码和数据空间,每个线程有独立的运行栈和程序计数器(PC),线程切换开销小.(线程是cpu调度的最小单位) 切换而不是同步 一个程序中的方法有几条执行路径, 就有几个线程 Java中线程的生命周期 Java线程具有五中基本状态 新建状态(New):当线程对象对创建后,即进入了新建状态,如:Thread t =

Java线程常用方法详解

线程的常用方法 1．start() : 线程调用该方法将启动线程,使之从新建状态进入就绪队列排队,一旦轮到它来享用CPU资源时,就可以脱离创建它的线程独立开始自己的生命周期了. 2．run(): Thread类的run()方法与Runnable接口中的run()方法的功能和作用相同,都用来定义线程对象被调度之后所执行的操作,都是系统自动调用而用户程序不得引用的方法. 3．sleep(int millsecond): 优先级高的线程可以在它的run()方法中调用sleep方法来使自己放弃CPU资源

Java线程唤醒与阻塞常用方法有哪些？

如果线程是因为调用了wait().sleep()或者join()方法而导致的阻塞,可以中断线程,并且通过抛出InterruptedException来唤醒它:如果线程遇到了IO阻塞,无能为力,因为IO是操作系统实现的,Java代码并没有办法直接接触到操作系统.以下是详细的唤醒方法: 1. sleep() 方法 sleep(毫秒),指定以毫秒为单位的时间,使线程在该时间内进入线程阻塞状态,期间得不到cpu的时间片,等到时间过去了,线程重新进入可执行状态.(暂停线程,不会释放锁) 2.suspend

java基础——线程的常用方法和线程生命周期

线程的常用方法 package thread; /* 测试Thread类中的常用方法: 1.start() 2.run():重写Thread方法,将线程要执行的操作声明在方法中 3.Thread.currentThread():静态方法,返回执行当前代码的线程 4.getName():获取当前线程的名字 5.setName():设置当前线程的名字 6.yield():当前线程交出cpu执行权 7.join():在线程a中调用线程b的join方法,此时线程a进入阻塞态,直到线程b完全执行完后,a才

Java线程使用大全

1.线程实现 1.Thread类 构造方法: 案例代码: public class Ex10_1_CaseThread extends Thread {// 创建一个类继承(extend)Thread类 String studentName; public Ex10_1_CaseThread(String studentName) {// 定义类的构造函数,传递参数 System.out.println(studentName + "申请访问服务器"); this.studentNam

java线程详细介绍

目录(?)[-] 一扩展javalangThread类 二实现javalangRunnable接口 三Thread和Runnable的区别 四线程状态转换 五线程调度 六常用函数说明 使用方式 为什么要用join方法 七常见线程名词解释 八线程同步 九线程数据传递 本文主要讲了java中多线程的使用方法.线程同步.线程数据传递.线程状态及相应的一些线程函数用法.概述等. 首先讲一下进程和线程的区别: 进程:每个进程都有独立的代码和数据空间(进程上下文),进程间的切换会有较大的开销,一个进程包含1

java——线程

线程是一个程序里面不同的执行路径. 线程的的创建和启动 1. 定义线程类实现Runnable接口 public class TestThread1 { public static void main(String arg[]) { Runner1 r=new Runner1(); Thread t=new Thread(r); //Thread的实例来创建新的的线程 t.start(); //start方法来启动一个线程 for(int i=0;i<100;i++) { System.out.p

java 线程基本用法

java中的多线程 一.      java 线程基本介绍 1.进程与线程的区别 进程是指一个内存中运行的应用程序,每个进程都有一块独立的内存空间,一个进程包含一到多个线程. 每个线程都有他所属的进程,每个线程也就是该进程的一条执行路径,线程之间是高频率快速轮换执行的,‘同时’执行只是给人的感觉. 2.Java当中线程一般有5中状态 创建状态:生成线程对象,并没有调用该对象的start方法,这是线程处于创建状态. 就绪状态:当调用了线程的start方法,线程就进入就绪状态,调用start方法后线

java多线程的常用方法（以及注意事项）

1 /* 2 * 线程的常用方法 3 * 1.start(); 4 * 2.run(); 5 * 3.sleep(int millsecond); 6 * 4.isAlive(); -->判断线程是否还在运行 7 * 5.currentThread(); -->返回当前正在使用CPU资源的线程 8 * 6.interrupt(); -->激活休眠的线程 9 * */ 但是需要注意的一个小点是: 1 /* 2 * 需要注意到地方:一个已经运行的线程在没有进入死亡状态时, 3 * 不要在给线