精华内容
下载资源
问答
  • Thread类方法

    千次阅读 2019-11-24 21:57:05
    Thread类中的常用的方法: 1. start():启动当前线程;调用当前线程的run() 2. run(): 通常需要重写Thread类中的此方法,将创建的线程要执行的操作声明在此方法中 3. currentThread():静态方法,返回执行当前代码的...
    Thread类中的常用的方法:
    
    1. start():启动当前线程;调用当前线程的run()
    2. run(): 通常需要重写Thread类中的此方法,将创建的线程要执行的操作声明在此方法中
    3. currentThread():静态方法,返回执行当前代码的线程
    4. getName():获取当前线程的名字
    5. setName():设置当前线程的名字
    6. yield():释放当前cpu的执行权
    7. join():在线程a中调用线程b的join(),此时线程a就进入阻塞状态,直到线程b完全执行完以后,线程a才结束阻塞状态。
    8. stop():已过时。当执行此方法时,强制结束当前线程。
    9. sleep(long millitime):让当前线程“睡眠”指定的millitime毫秒。在指定的millitime毫秒时间内,当前线程是阻塞状态。
    10. isAlive():判断当前线程是否存活
    
    线程的优先级:1.MAX_PRIORITY:10MIN _PRIORITY:1NORM_PRIORITY:5  -->默认优先级2.如何获取和设置当前线程的优先级:  getPriority():获取线程的优先级  setPriority(int p):设置线程的优先级说明:高优先级的线程要抢占低优先级线程cpu的执行权。但是只是从概率上讲,高优先级的线程高概率的情况下被执行。并不意味着只当高优先级的线程执行完以后,低优先级的线程才执行。
    
    线程通信:wait() / notify() / notifyAll() :此三个方法定义在Object类中的。
    
    补充:线程的分类
    一种是守护线程,一种是用户线程。
    
    
    展开全文
  • Thread类的几种常用方法

    万次阅读 2018-08-27 16:45:00
    2.run 此run非彼run (不是在run方法实现线程的逻辑,而是thread.run(),这个run方法是直接调用了线程中的run) 3.yield(暂停当前线程,并执行其他线程) 4.sleep(使当前线程由运行状态变成阻塞状态,若睡眠时...

    1.start(开启线程,start是通过线程来调用run方法)

    2.run   此run非彼run (不是在run方法实现线程的逻辑,而是thread.run(),这个run方法是直接调用了线程中的run)

    3.yield(暂停当前线程,并执行其他线程)

    4.sleep(使当前线程由运行状态变成阻塞状态,若睡眠时其他线程调用了interrupt方法,会导致sleep抛出异常InterruptException)

    5.join(保证当前线程在其他线程开始时会结束)(如下,A线程想运行的话,必须等B线程结束才能运行(将处于阻塞状态))

     Thread A{

    run{

    new ThreadB.join();

    }

    }.start;

    6.interrupt(中断线程)

    7.wait/notify(从Object类继承下来的方法)

    8.setPriority(设置线程优先级(只能在线程开始前设置))

    9.stop(强制结束线程)

    展开全文
  • Java中Thread类方法简介

    万次阅读 2018-06-05 17:37:48
    Thread t1 = new Thread(); t1.start(); 新建线程,应该调用start()方法启动线程;如果直接调用run()方法,该方法也会执行,但会被当做一个普通的方法,在当前线程中顺序执行;而如果使用start()方法,则会创建一个...

    1.新建线程

    Thread t1 = new Thread();
    t1.start();

    新建线程,应该调用start()方法启动线程;如果直接调用run()方法,该方法也会执行,但会被当做一个普通的方法,在当前线程中顺序执行;而如果使用start()方法,则会创建一个新的线程执行run()方法。

    2.线程中断

    public void interrupt();
    public boolean isInterrupted();
    public static boolean interrupted();

    三个方法很相似,线程中断只是通知目标线程有人希望你退出,而并不是使目标线程退出。
    第一个方法是通知目标线程中断,即设置目标线称的中断标志位;
    第二个方法判断当前线程是否被中断,如果被中断(即中断标志位被设置),则返回true,否则返回false;
    第三个方法判断当前线程的中断状态,并清除该线程的中断标志位(也就意味着,如果连续调用两次该方法,并且中间没有再次设置中断标志位,第二次会返回false,因为中断标志位已经被清除)。

    public static native void sleep(long millis) throws InterruptedException;

    sleep()方法会将当前线程休眠若干ms,如果在休眠期间被调用interrupt()方法,则会抛出InterruptedException异常。如下:

    public class TestThread implements Runnable{
        @Override
        public void run() {
            while(true) {
                if(Thread.currentThread().isInterrupted()){ //如果当前线程已经被设置了中断标志位,则返回true
                    System.out.println("Interrupted");
                    break;
                }
    
                try {
                    Thread.currentThread().sleep(1000);
                } catch (InterruptedException e) {
                    System.out.println("Interruted when sleep!");
                    Thread.currentThread().interrupt(); //Thread.sleep()方法由于中断而抛出异常,此时,它会清除中断标记;
                }
    
                Thread.yield();
            }
        }
    
        public static void main(String[] args){
            Thread t1 = new Thread(new TestThread());
            t1.start();
    
            t1.interrupt(); //设置目标线程的中断标志位,中断标志位表示当前线程已经被中断了
        }
    }

    3.等待(wait)和通知(notify)

    public final void wait() throws InterruptedException;
    public final native void notify();
    public final native void notifyAll();

    obj.wait()是设置当前线程在该对象上等待,直到有线程调用obj.notify()方法(或notifyAll()方法)。当调用wait()方法后,该线程会进入一个等待队列,等待队列中可能有多个线程,notify()会随机唤醒其中一个线程,而notifyAll()会唤醒所有线程。
    wait()和notify()方法必须在sychronized代码块中,调用这些方法时都需要先获得目标对象的一个监视器,然后调用这些方法时会释放监视器
    与sleep不同的是,sleep()会一直占有所持有的锁,而wait()会释放锁。

    4.等待线程(join)和谦让(yield)

    public final void join() throws InterruptedException;
    public static native void yield();

    如果一个线程的执行需要另一个线程的参与(比如当前线程执行需要另一个线程执行完毕才能继续执行),这时候可以调用join()方法。t1.join()方法表示等待线程t1执行完毕之后,当前线程再继续执行。当然也可以给join()设置时间参数。
    注:join()的本质是让调用线程wait()在当前线程对象实例上,其部分源码如下:

    while (isAlive()) {
       wait(0);
    }

    当线程执行完毕后,它会让被等待的线程在退出前调用notifyAll()通知所有等待的线程继续执行。因此不要在Thread对象实例上使用类似wait()或者notify()等方法。
    yield()方法是使当前线程让出CPU,但该线程会再次抢夺CPU。

    展开全文
  • 忘了为啥之前查的用上bind了,...Case 1 : 根据内函数创建thread class A { public:  A();  ~A();  void run(int i) {  cout  }  void thread_run() {  for (int i = 0; i  thread t(&A::r

    忘了为啥之前查的用上bind了,把项目搞完之后终于有时间建个小工程仔细试下怎么用。

    Case 1 : 根据类内函数创建thread

    class A
    {
    public:
     A();
     ~A();
     void run(int i) {
      cout << i << endl;
     }
     void thread_run() {
      for (int i = 0; i < 5; ++i) {
       thread t( &A::run, this, i);
       t.join();
      }
     }
    };


    int main() {

     A a;
     a.thread_run();

     return 0;
    }



    Case 2 : 在类外根据某一个类的函数创建thread

    class A
    {
    public:
     A();
     ~A();
     void run(int i) {
      cout << i << endl;
     }
    };



    int main() {

     A a;
     for (int i = 0; i < 5; ++i) {
      thread t(&A::run, &a, i);
      t.join();
     }

     return 0;
    }


    Case 3 : 在一个类中根据另一个类的函数创建thread

    class A
    {
    public:
     A();
     ~A();
     void run(int i) {
      cout << i << endl;
     }
    };


    class B
    {
    public:
     B();
     ~B();
     void run() {
      A a;
      for (int i = 0; i < 1000; ++i) {
       thre.fdad t(&A::run, &a, i);
       t.join();
      }
     }
    };

    int main() {
     A a;
     B b;
     b.run();
     return 0;
    }

    居然都是完全没问题的!!!我就奇怪了当初在工程里为毛怎么都不行。

    注意点大概如下:
    1. thread的第一个参数一定是 &类名::函数名 的形式
    2. thread的第二个参数一定是类实例的指针
    3. thread的之后的参数是函数所需要的参数

    另外这样for循环创建的thread一定是执行完一个线程才创建下一个线程的,如果想要线程一起创建,需要先用一个vector把创建的thread存起来(千万不能直接存实例,因为vector在push_back时会再次构造),之后再一个for循环一起join;或者直接把join改成detach。

    比较坑的地方可能就是thread传入类的函数和全局函数或者static函数时,参数是有区别的(后两个不需要类实例的指针),可能就是因为这个才让我当初怎么搞都没搞通吧。

    展开全文
  • Java Thread类主要方法详解

    万次阅读 2018-09-13 00:48:41
    在java中,谈到线程,必然少不了Thread类。线程是比进程更轻量级的调度执行单位。为什么用线程?通过使用线程,可以把操作系统进程的资源分配和执行调度分开,各个线程既可以共享进程资源(内存地址、文件I/O等),...
  • java中Thread类方法介绍

    千次阅读 2016-11-29 17:13:05
    方法摘要  static int activeCount()   返回当前线程的线程组中活动线程的数目。   void checkAccess()   判定当前运行的线程是否有权修改该线程。   int countStackFrames()   已过时。 该调用的...
  • Thread类isAlive方法

    千次阅读 2019-07-08 15:11:25
    方法isAlive() 的功能是判断当前的线程是否处于活动状态;活动状态就是线程已经启动尚未终止,那么这时候线程就是存活的,则返回true,否则则返回false; 《多线程核心技术》书中讲到isAlive() 时提到,线程作为...
  • Thread 部分常用方法详解

    千次阅读 2020-09-29 23:25:21
    currentThread() 方法用来返回代码段正在被哪个线程调用,它是 Thread 提供的一个 native 方法,返回一个 Thread 的实例对象,源码如下: public static native Thread currentThread(); 废话就不多说了,直接...
  • java中Thread类的join方法

    千次阅读 2017-11-13 13:21:03
    那么我们如何实现让线程T1,T2,T3,在T1执行完成后才执行T2,T2执行完成后才执行T3,也就是线程的串行化,通过Thread类的join方法就可以实现。 join方法:将该线程加入当前线程,当前线程等待加入线程执行完成...
  • Thread类、Runnable接口详解

    千次阅读 2019-12-26 23:08:02
    Thread类想必都不陌生,第一次学习多线程的时候就一定会接触Thread类。本篇主要从Thread类的定义、使用、注意事项、源码等方面入手,全方位的讲解Thread类。 Thread 我们经常会被问到这样一个问题: Java开启一个新...
  • 参见C++使用thread类多线程编程 。 二、类外使用多线程,访问类的成员 这几种方式,新建线程都是在类外,然后通过把友元函数或者成员函数作为thread参数。 #include &lt;iostream&gt; #include &lt;...
  • Thread类中sleep是为什么是静态方法

    千次阅读 2015-09-01 15:53:05
    Thread类中sleep是静态方法,表示当前线程休眠。 Thread的API  public static native void sleep(long millis) throws InterruptedException; /**   * Causes the currently executing thread to s
  • 1. Thread类中的常用方法简介 2. Join()方法 3. Sleep() 方法:不会释放锁 4. Yield()方法:线程让步 不会释放锁 1. Thread类中的常用方法简介 首先,先看一下Thread类中的常见方法: 最主要的是区分其中...
  • 【Java】Thread类中的join()方法原理

    万次阅读 多人点赞 2018-05-09 18:34:09
    join()是Thread类的一个方法。根据jdk文档的定义: public final void join()throws InterruptedException: Waits for this thread to die. join()方法的作用,是等待这个线程结束;但显然,这样的定义并不清晰...
  • Java中Thread类的start()方法和run()方法

    千次阅读 2017-07-05 18:29:17
    我们知道在Java中可以通过继承一个Thread类来实现一个线程类,继承以后,需要重载run()方法,但是在启动线程的时候则又是用start()方法,这个是几个意思,启动直接用run()不行么,我们试一下。首先还是用start()方法...
  • 多线程——Thread类的常用方法

    千次阅读 2018-01-30 22:23:46
    本博客主要针对Thread类的常用的方法进行介绍,包括:构造方法、静态方法和非静态方法,作为自我总结。1. Thread类的构造方法根据Java api,Thread类的构造方法共有8个:Thread() Thread(Runnable target) Thread...
  • 在生成线程对象的时候,并没有调用start方法,这是线程的创建状态。 2:就绪(RUNABLE) 当调用线程对象的start方法以后,线程就进入了就绪状态。但是此时线程调度程序还没有把该线程设置为当前线程,此时处于就绪状态...
  • Thread类

    万次阅读 2018-03-25 15:41:09
    1 start方法 start()用来启动一个线程,当调用start方法后,系统才会开启一个新的线程来执行用户定义的子任务,在这个过程中,会为相应的线程分配需要...注意,继承Thread类必须重写run方法,在run方法中定义具体要...
  •  在java.lang.Thread类中,提供了sleep(), 而java.lang.Object类中提供了wait(), notify()和notifyAll()方法来操作线程 sleep()可以将一个线程睡眠,参数可以指定一个时间。 而wait()可以将一个线程挂起,...
  • Thread类的run()和start()方法的区别

    万次阅读 2018-03-15 11:36:26
    start()方法来启动线程,真正实现了多线程运行,这时无需等待run方法体代码执行完毕而直接继续执行下面的代码: 通过调用Thread类的start()方法来启动一个线程,这时此线程是处于就绪状态,并没有运行。...
  • Java并发编程——解析Thread类

    千次阅读 多人点赞 2019-08-28 22:05:20
    Callable 接口3.3 继承 Thread 类3.4 实现接口 VS 继承 Thread四、Thread类详解4.1 线程运行状态4.1.1 start()方法4.1.2 run 方法4.1.3 sleep 方法4.1.4 yield方法4.1.5 join方法4.1.6 int...
  • sleep()方法(休眠)是线程Thread)的静态方法,调用此方法会让当前线程暂停执行指定的时间,将执行机会(CPU)让给其他线程,但是对象的锁依然保持,因此休眠时间结束后会自动恢复(线程会回到就绪状态)。...
  • Thread类常用方法

    千次阅读 2018-01-02 14:31:18
    Thread类构造方法:1.Thread();2.Thread(String name);3.Thread(Runable r);4.Thread(Runable r, String name);[java] view plain copypublic class Test { public static void main(String[]...
  • 多线程获取名字Thread类方法getName

    千次阅读 2018-06-27 14:53:56
    子类NameThread继承Thread:/* * 获取线程名字,父类Thread方法 * String getName() */public class NameThread extends Thread { public void run(){ System.out.println(super.getName()); }}测试Demo:/*...
  • 一、初识 java的线程是通过java.lang.Thread类来实现的。VM启动时会有一个由主方法所定义...通过调用Thread类的start()方法来启动一个线程。 在Java当中,线程通常都有五种状态,创建、就绪、运行、阻塞和死亡。 ...
  • #include <thread> #include class classA { public : classA() { std::cout; } void func(int a, const char *pchText) { std::cout; m_a = a; std::cout; } void func2() { std:...
  • thread类中start()和run()方法的区别

    千次阅读 2019-04-12 11:08:21
    run方法体代码执行完毕而直接继续执行下面的代码: 通过调用Thread类的start()方法来启动一个线程,这时此线程是处于就绪状态,并没有运行。 然后通过此Thread类调用方法run()来完成其运行操作的,这里方法run()称为...
  • 区别:调用start方法实现多线程,而调用run方法没有实现多线程 (run没有另起线程,而...通过调用Thread类的start()方法来启动一个线程,这时此线程处于就绪(可运行)状态,并没有运行,一旦得到spu时间片,就开始执...
  • Java Thread类源码详解

    千次阅读 2018-08-23 14:51:18
    Java所有多线程的实现,均通过封装Thread类实现,所以深入Thread类,对深入理解java多线程很有必要 构造函数: Thread的构造函数,采用缺省的方式实现: //传入Runnable接口实现 Thread...
  • 子线程类 extends Thread时是可以不用重写run()方法,但是当你 子线程类对象.start()方法就是调Thread类的run()方法了。而Thread类的run()方法不执行任何操作并返回。  implements Runnable时是必须重写run()...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 759,607
精华内容 303,842
关键字:

哪些是thread类的方法