精华内容
下载资源
问答
  • 1. 前言线程与进程的理解详见:https://blog.csdn.net/qq_38969070/article/details/80424079多线程处理...(2) 从程序员的角度来看,你在应用开始时,应该只有一个线程, 称之为主线程(main t...

    1.    前言

    线程与进程的理解详见:https://blog.csdn.net/qq_38969070/article/details/80424079

    多线程处理(Multithreaded execution)是Java平台的基本特征:

    (1)    每个应用至少有一个线程。

    (2)    从程序员的角度来看,你在应用中开始时,应该只有一个线程,

                 称之为主线程(main thread),该主线程可以创建其他的线程。

    使用多线程的好处:在多核处理器上运行更快,效率更高,是Java的生命所在。

    "In Java, threads are a fact of life."

    2.    创建一个线程的方法:

    主要有两种,一是从Thread类中派生出子类(使用较少),

    另一种是从Runnable接口构造Thread对象(通常使用)。

    (1)    方法一:从Thread类派生

      由于Thread类本身即实现了接口Runnable,只是其run方法没有任何功能,

      因此我们只需要继承Thread,重写自己的run()方法即可。

      实例如下:

    public class HelloThread extends Thread {
      public void run() {
        System.out.println("Hello from a thread");
      }
      public static void main(String[] args) {
        HelloThread p = new HelloThread();
        p.start();
      }
    }

    (2)    方法二:提供一个Runnable对象

       由于Runnable接口只有一个方法-run(),因此继承该接口,实现run()方法,

       再将其作为参数传递给Thread的构造器即可。

       实例如下:

    public class HelloRunnable implements Runnable{
      
      public void run() { 
        System.out.println("Hello from a thread!"); 
      }
      public static void main(String args[]) { 
        (new Thread(new HelloRunnable())).start(); 
      }
    
    }
    
       

    3.    易混淆之处

    (1)    对Runnable与Thread应加以区别。

      例:理解Runnable和Thread的方法和意义


    (2)    不使用start()方法,线程是不能运行的。

      例:创建一下三个线程


    只有前两个线程会运行,因此只打印前两个字符串。


    展开全文
  • java中Thread类的join方法

    千次阅读 2017-11-13 13:21:03
    那么我们如何实现让线程T1,T2,T3,在T1执行完成后才执行T2,T2执行完成后才执行T3,也就是线程的串行化,通过Thread类的join方法就可以实现。 join方法:将该线程加入当前线程,当前线程等待加入线程执行完成...
    单核cpu运行多线程时底层实现原理是多个线程间切换,由于cpu的处理速度很快,看上去像多个线程同时运行。那么我们如何实现让线程T1,T2,T3,在T1执行完成后才执行T2,T2执行完成后才执行T3,也就是线程的串行化,通过Thread类的join方法就可以实现。

    join方法:将该线程加入当前线程,当前线程等待加入线程执行完成才继续执行。
    例子:
    public class ThreadJoinTest implements Runnable {
    public static void main(String[] args) throws InterruptedException {
    Thread thread = new Thread(new ThreadJoinTest());
    thread.start();
    thread.join();
    System.out.println("主线程结束");
    }

    @Override
    public void run() {
    System.out.println("子线程开始");
    for(int i = 0; i < 5; i++) {
    try {
    Thread.sleep(1000);
    } catch (InterruptedException e) {
    e.printStackTrace();
    }
    System.out.println(i);
    }
    System.out.println("子线程结束");
    }
    }
    执行结果:
    join(long  millis)方法:将该线程加班当前线程,当前线程等待加入线程millis时间,当达到millis时间后不管加入线程是否完成,当前线程都继续执行,若加入线程在小于millis时间执行完成,则当前线程等待时间等于加入线程的执行时间。
    例子:
    public class ThreadJoinTest implements Runnable {
    public static void main(String[] args) throws InterruptedException {
    Thread thread = new Thread(new ThreadJoinTest());
    thread.start();
    thread.join(2000);
    System.out.println("主线程结束");
    }

    @Override
    public void run() {
    System.out.println("子线程开始");
    for(int i = 0; i < 5; i++) {
    try {
    Thread.sleep(1000);
    } catch (InterruptedException e) {
    e.printStackTrace();
    }
    System.out.println(i);
    }
    System.out.println("子线程结束");
    }
    }
    执行结果:

    展开全文
  • 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。

    展开全文
  • java中Thread类的join()方法

    万次阅读 2012-03-10 11:45:47
    Thread类中有一个join()方法,在一个线程启动另外一个线程的join方法,当前线程将会挂起,而执行被启动的线程,知道被启动的线程执行完毕后,当前线程才开始执行。 下面我们新建两个继承Thread,让其中一个...

    Thread类中有一个join()方法,在一个线程中启动另外一个线程的join方法,当前线程将会挂起,而执行被启动的线程,知道被启动的线程执行完毕后,当前线程才开始执行。

    下面我们新建两个继承Thread的类,让其中一个线程在另外一个线程中调用join方法

    class Thread1 extends Thread
    {
    	public Thread1(String threadName)
    	{	
    		super(threadName);
    	}
    	
    	public void run()
    	{
    		System.out.println(getName() + "is running");
    		try
    		{
    			sleep(2000);
    		} 
    		catch (InterruptedException e)
    		{
    			e.printStackTrace();
    		}
    	}
    }

    class Thread2 extends Thread
    {
    	private Thread1 thread1;
    	
    	public Thread2(String threadName, Thread1 thread1)
    	{
    		super(threadName);
    		this.thread1 = thread1;		
    	}
    	
    	public void run()
    	{
    		System.out.println(getName() +  "is running");
    		try
    		{
    			thread1.start();
    			thread1.join();
    		} 
    		catch (InterruptedException e)
    		{
    			e.printStackTrace();
    		}
    		System.out.println("thread2 is over");	
    	}
    }
    
    package com.thread;
    
    public class JoinTest
    {
    	public static void main(String[] args)
    	{
    		Thread1 thread1 = new Thread1("Thread1");
    		Thread2 thread2 = new Thread2("Thread2", thread1);
    		thread2.start();
    	}
    }


    
    我们在thead2中调用thread1的join()方法,让thread1中断thread2自身的运行,运行程序首先输出thread2 is running,然后输出thread1 is running, 过了两秒钟之后,才输出thread2 is over,这就说明在thread2中调用thread1的join()方法,thread2自身被中断了,转而执行thread1,等待thread1执行完毕之后,再转过来执行thread2

    展开全文
  • Java中Thread类的start()方法和run()方法

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

    万次阅读 多人点赞 2017-01-11 20:44:31
     Java Thread类 的各种操作与线程的生命周期密不可分,了解线程的生命周期有助于对Thread类中的各方法的理解。一般来说,线程从最初的创建到最终的消亡,要经历创建、就绪、运行、阻塞 和 消亡 五个状态。在线程...
  • Java中使用Thread类

    千次阅读 2018-07-17 15:12:45
    那么JVM就要在主线程和其他线程之间轮流切换,保证每个线程都有机会使用CPU资源,main方法即使执行完最后的语句(主线程结束),JVM也不会结束Java应用程序,JVM一直要等到Java应用程序的所有线程都结束之后,才会...
  • Java Thread类源码详解

    千次阅读 2018-08-23 14:51:18
    Java所有多线程的实现,均通过封装Thread类实现,所以深入Thread类,对深入理解java多线程很有必要 构造函数: Thread的构造函数,采用缺省的方式实现: //传入Runnable接口实现 Thread...
  • JavaThread类中的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用法

    万次阅读 2015-05-13 10:02:11
    上下文切换三.Thread类中的方法线程的状态 在正式学习Thread类中的具体方法之前,我们先来了解一下线程有哪些状态,这个将会有助于后面对Thread类中的方法的理解。 线程从创建到最终的消亡,要经历若干个状态。...
  • Java 中Thread用法

    万次阅读 2015-07-20 11:40:14
    2、Java 线程的运行:构造一个Thread类的实例(主要有两种方法),调用其start()方法,如:Thread t = new Thread(); t.start();这是一个空壳线程,不做任何事,创建之后就退出。 构造一个Thread类的实例的两种方法...
  • Java Thread类主要方法详解

    万次阅读 2018-09-13 00:48:41
    java中,谈到线程,必然少不了Thread类。线程是比进程更轻量级的调度执行单位。为什么用线程?通过使用线程,可以把操作系统进程的资源分配和执行调度分开,各个线程既可以共享进程资源(内存地址、文件I/O等),...
  • java提供了两种线程方式,一种是继承java.lang包下的Thread类,覆写Thread类的run()方法,在run()方法实现运行在线程上的代码!第二种是实现Runnable接口创建多线程。下面就跟大家具体的介绍一下这两种方式! 在...
  • java中的daemon thread

    千次阅读 2020-03-18 09:07:39
    java中的daemon thread java中有两种类型的thread,user threads 和 daemon threads。 User threads是高优先级的thread,JVM将会等待所有的User Threads运行完毕之后才会结束运行。 daemon threads是低优先级的...
  • 线程我只写过继承Thread类的,后来知道java多线程有三种方式,今天首先比较一下常用的继承Thread类和实现Runnable接口的区别。  按着Ctrl键进入Thread之后,发现Thread类也是Runnable接口的之,这应该就是它们...
  • java中Thread与Runnable的区别

    千次阅读 2010-12-11 11:30:00
    java中可有两种方式实现多线程,一种是继承Thread类,一种是实现Runnable接口;Thread类是在java.lang包中定义的。一个只要继承了Thread类同时覆写了本类中的run()方法就可以实现多线程操作了,但是一个只能...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 1,072,800
精华内容 429,120
关键字:

java中thread类

java 订阅