精华内容
下载资源
问答
  • Java线程实现方式

    千次阅读 2018-04-16 18:56:27
    Java线程实现方式 Java线程实现方式 实现方式 不同实现方式的差异 实现方式 Java多线程共有四种不同的实现方式:分别为继承Thread类、实现Runnable接口,实现Callable接口 并...

    实现方式

    Java多线程共有四种不同的实现方式:分别为继承Thread类、实现Runnable接口,实现Callable接口并通过FutureTask包装器创建线程,使用ExecutorService、Callable、Future实现多线程。

    继承Thread类实现多线程

    Thread类本质上实现了Runnable接口,代表一个线程的实例。启动线程的唯一方法是调用类的start方法。start方法是一个native方法,它将启动一个新线程,并执行run方法。

    以这种方式实现多线程较为简单:首先定义自己的类,然后自己的类继承Thread类,并重写run()方法,调用start方法就可以启动一个新线程并执行run方法。示例如下:

    public class ThreadDemo extends Thread{
    	public void run(){
    		System.out.println("ThreadDemo start..");
    	}
    
    	public static void main(String[] args) {
    		ThreadDemo td = new ThreadDemo();
    		td.start();
    	}
    }
    

    实现Runnable接口实现多线程。示例如下:

    public class RunnableDemo implements Runnable{
    	@Override
    	public void run() {
    		System.out.println("RunnableDemo start..");
    	}
    
    	public static void main(String[] args) {
    		RunnableDemo rd = new RunnableDemo();
    		Thread t = new Thread(rd);
    		t.start();
    	}
    }
    

    实现Callable接口并通过FutureTask包装器创建线程。示例如下:

    public class CallableDemo{
    	public static void main(String[] args) throws InterruptedException, ExecutionException {
    		Callable<Integer> call = new Callable<Integer>() {
                @Override
                public Integer call() throws Exception {
                    System.out.println("callable thread start..");
                    Thread.sleep(2000);
                    return 1;
                }
            };
    
            FutureTask<Integer> task = new FutureTask<>(call);
            Thread t =  new Thread(task);
            t.start();
       
            System.out.println("do other thing..");
            System.out.println("callable res=" + task.get());
    	}
    }
    

    使用ExecutorService、Callable、Future实现多线程。示例如下:

    public class ExecutorServiceDemo {
    	public static void main(String[] args) throws InterruptedException, ExecutionException {
    		System.out.println("main start..");
    		int taskSize = 5;
    
    		ExecutorService pool = Executors.newFixedThreadPool(taskSize);
    		List<Future<Integer>> list = new ArrayList<Future<Integer>>();
    		for (int i = 0; i < taskSize; i++) {
    			Callable<Integer> c = new MyCallable<Integer>(i + " ");
    			Future<Integer> f = pool.submit(c);
    			list.add(f);
    		}
    
    		pool.shutdown();
    
    		for (Future<Integer> f : list) {
    			System.out.println("threads res=" + f.get());
    		}
    	}
    }
    
    class MyCallable<Integer> implements Callable<Integer> {
    	private String taskNum;
    
    	MyCallable(String taskNum) {
    		this.taskNum = taskNum;
    	}
    
    	public Integer call() throws Exception {
    		System.out.println("---" + taskNum + " thread start");
    		Date dateStart = new Date();
    		Thread.sleep(1000);
    		Date dateEnd = new Date();
    		long time = dateEnd.getTime() - dateStart.getTime();
    		return (Integer) (taskNum + " end require[" + time + "ms]");
    	}
    }
    

    不同实现方式的差异

    • 如果自己定义的类已经继承了其他类,由于java是单根继承,故只能通过实现接口实现多线程。
    • 继承Thread类和实现Runnable接口实现多线程,没有返回值;实现Callable接口和利用ExecutorService实现多线程可以有返回值,并封装与FutureTask和Future中,值得注意的是,获取返回值的get方法,是阻塞方法,即必须等到线程执行结束才能得到返回值。
    • 继承Thread类和实现Runnable接口实现多线程,不能抛出异常;实现Callable接口和利用ExecutorService
      实现多线程,可以抛出异常。
    展开全文
  • JAVA线程实现的三种方式

    千次阅读 2016-08-25 10:43:23
    JAVA线程实现方式主要有三种:继承Thread类、实现Runnable接口、使用ExecutorService、Callable、Future实现有返回结果的多线程。其中前两种方式线程执行完后都没有返回值,只有最后一种是带返回值的。 2.继承...

    最近在做代码优化时学习和研究了下JAVA多线程的使用,看了菜鸟们的见解后做了下总结。
    1.JAVA多线程实现方式
    JAVA多线程实现方式主要有三种:继承Thread类、实现Runnable接口、使用ExecutorService、Callable、Future实现有返回结果的多线程。其中前两种方式线程执行完后都没有返回值,只有最后一种是带返回值的。

    2.继承Thread类实现多线程
    继承Thread类的方法尽管被我列为一种多线程实现方式,但Thread本质上也是实现了Runnable接口的一个实例,它代表一个线程的实例,并且,启动线程的唯一方法就是通过Thread类的start()实例方法。start()方法是一个native方法,它将启动一个新线程,并执行run()方法。这种方式实现多线程很简单,通过自己的类直接extend Thread,并复写run()方法,就可以启动新线程并执行自己定义的run()方法。例如:
    public class MyThread extends Thread {
      public void run() {
       System.out.println("MyThread.run()");
      }
    }
    在合适的地方启动线程如下:
    MyThread myThread1 = new MyThread();
    MyThread myThread2 = new MyThread();
    myThread1.start();
    myThread2.start();

    3.实现Runnable接口方式实现多线程
    如果自己的类已经extends另一个类,就无法直接extends Thread,此时,必须实现一个Runnable接口,如下:
    public class MyThread extends OtherClass implements Runnable {
      public void run() {
       System.out.println("MyThread.run()");
      }
    }
    为了启动MyThread,需要首先实例化一个Thread,并传入自己的MyThread实例:
    MyThread myThread = new MyThread();
    Thread thread = new Thread(myThread);
    thread.start();
    事实上,当传入一个Runnable target参数给Thread后,Thread的run()方法就会调用target.run(),参考JDK源代码:
    public void run() {
      if (target != null) {
       target.run();
      }
    }

    4.使用ExecutorService、Callable、Future实现有返回结果的多线程
    ExecutorService、Callable、Future这个对象实际上都是属于Executor框架中的功能类。想要详细了解Executor框架的可以访问http://www.javaeye.com/topic/366591 ,这里面对该框架做了很详细的解释。返回结果的线程是在JDK1.5中引入的新特征,确实很实用,有了这种特征我就不需要再为了得到返回值而大费周折了,而且即便实现了也可能漏洞百出。

    可返回值的任务必须实现Callable接口,类似的,无返回值的任务必须Runnable接口。执行Callable任务后,可以获取一个Future的对象,在该对象上调用get就可以获取到Callable任务返回的Object了,再结合线程池接口ExecutorService就可以实现传说中有返回结果的多线程了。下面提供了一个完整的有返回结果的多线程测试例子,在JDK1.5下验证过没问题可以直接使用。代码如下:

    import java.util.concurrent.*;
    import java.util.Date;
    import java.util.List;
    import java.util.ArrayList;
    
    /**
    * Java线程:有返回值的线程
    * 
    * @author wb_qiuquan.ying
    */
    @SuppressWarnings("unchecked")
    public class Test {
    public static void main(String[] args) throws ExecutionException,
        InterruptedException {
       System.out.println("----程序开始运行----");
       Date date1 = new Date();
    
       int taskSize = 5;
       // 创建一个线程池
       ExecutorService pool = Executors.newFixedThreadPool(taskSize);
       // 创建多个有返回值的任务
       List<Future> list = new ArrayList<Future>();
       for (int i = 0; i < taskSize; i++) {
        Callable c = new MyCallable(i + " ");
        // 执行任务并获取Future对象
        Future f = pool.submit(c);
        // System.out.println(">>>" + f.get().toString());
        list.add(f);
       }
       // 关闭线程池
       pool.shutdown();
    
       // 获取所有并发任务的运行结果
       for (Future f : list) {
        // 从Future对象上获取任务的返回值,并输出到控制台
        System.out.println(">>>" + f.get().toString());
       }
    
       Date date2 = new Date();
       System.out.println("----程序结束运行----,程序运行时间【"
         + (date2.getTime() - date1.getTime()) + "毫秒】");
    }
    }
    
    class MyCallable implements Callable<Object> {
    private String taskNum;
    
    MyCallable(String taskNum) {
       this.taskNum = taskNum;
    }
    
    public Object call() throws Exception {
       System.out.println(">>>" + taskNum + "任务启动");
       Date dateTmp1 = new Date();
       Thread.sleep(1000);
       Date dateTmp2 = new Date();
       long time = dateTmp2.getTime() - dateTmp1.getTime();
       System.out.println(">>>" + taskNum + "任务终止");
       return taskNum + "任务返回运行结果,当前任务时间【" + time + "毫秒】";
    }
    }


    展开全文
  • JAVA线程实现的四种方式

    千次阅读 2018-06-19 18:44:40
    Java线程实现方式主要有四种:继承Thread类、实现Runnable接口、实现Callable接口通过FutureTask包装器来创建Thread线程、使用ExecutorService、Callable、Future实现有返回结果的多线程。   其中前两种方式...

            Java多线程实现方式主要有四种:继承Thread类、实现Runnable接口、实现Callable接口通过FutureTask包装器来创建Thread线程、使用ExecutorService、Callable、Future实现有返回结果的多线程。

     

    其中前两种方式线程执行完后都没有返回值,后两种是带返回值的。

     

    1、继承Thread类创建线程

     

    • Thread类本质上是实现了Runnable接口的一个实例,代表一个线程的实例。
    • 启动线程的唯一方法就是通过Thread类的start()实例方法。
    • start()方法是一个native方法,它将启动一个新线程,并执行run()方法。
    • 这种方式实现多线程很简单,通过自己的类直接extend Thread,并复写run()方法,就可以启动新线程并执行自己定义的run()方法。

    例如:

    public class MyThread extends Thread {  
      public void run() {  
       System.out.println("MyThread.run()");  
      }  
    }  
     
    MyThread myThread1 = new MyThread();  
    MyThread myThread2 = new MyThread();  
    myThread1.start();  
    myThread2.start();  

     

    2、实现Runnable接口创建线程

     

    • 如果自己的类已经extends另一个类,就无法直接extends Thread,此时,可以实现一个Runnable接口,如下:
    public class MyThread extends OtherClass implements Runnable {  
      public void run() {  
       System.out.println("MyThread.run()");  
      }  
    }  

     

    • 为了启动MyThread,需要首先实例化一个Thread,并传入自己的MyThread实例:
    MyThread myThread = new MyThread();  
    Thread thread = new Thread(myThread);  
    thread.start();  

     

    • 事实上,当传入一个Runnable target参数给Thread后,Thread的run()方法就会调用target.run(),参考JDK源代码:
    public void run() {  
      if (target != null) {  
       target.run();  
      }  
    }  

     

    3、实现Callable接口通过FutureTask包装器来创建Thread线程

     

    • Callable接口(也只有一个方法)定义如下:   
    public interface Callable<V>   { 
      V call() throws Exception;  
     } 
    public class SomeCallable<V> extends OtherClass implements Callable<V> {
    
        @Override
        public V call() throws Exception {
            // TODO Auto-generated method stub
            return null;
        }
    
    }
    Callable<V> oneCallable = new SomeCallable<V>();   
    //由Callable<Integer>创建一个FutureTask<Integer>对象:   
    FutureTask<V> oneTask = new FutureTask<V>(oneCallable);   
    //注释:FutureTask<Integer>是一个包装器,它通过接受Callable<Integer>来创建,它同时实现了Future和Runnable接口。 
      //由FutureTask<Integer>创建一个Thread对象:   
    Thread oneThread = new Thread(oneTask);   
    oneThread.start();   
    //至此,一个线程就创建完成了。

    4、使用ExecutorService、Callable、Future实现有返回结果的线程

     

    • ExecutorService、Callable、Future三个接口实际上都是属于Executor框架。返回结果的线程是在JDK1.5中引入的新特征,有了这种特征就不需要再为了得到返回值而大费周折了。而且自己实现了也可能漏洞百出。
    • 可返回值的任务必须实现Callable接口。类似的,无返回值的任务必须实现Runnable接口。
    • 执行Callable任务后,可以获取一个Future的对象,在该对象上调用get就可以获取到Callable任务返回的Object了。
    • 注意:get方法是阻塞的,即:线程无返回结果,get方法会一直等待。
    • 再结合线程池接口ExecutorService就可以实现传说中有返回结果的多线程了。

    下面提供了一个完整的有返回结果的多线程测试例子,在JDK1.5下验证过没问题可以直接使用。代码如下:

    import java.util.concurrent.*;  
    import java.util.Date;  
    import java.util.List;  
    import java.util.ArrayList;  
      
    /** 
    * 有返回值的线程 
    */  
    @SuppressWarnings("unchecked")  
    public class Test {  
    public static void main(String[] args) throws ExecutionException,  
        InterruptedException {  
       System.out.println("----程序开始运行----");  
       Date date1 = new Date();  
      
       int taskSize = 5;  
       // 创建一个线程池  
       ExecutorService pool = Executors.newFixedThreadPool(taskSize);  
       // 创建多个有返回值的任务  
       List<Future> list = new ArrayList<Future>();    
       for (int i = 0; i < taskSize; i++) {  
        Callable c = new MyCallable(i + " ");  
        // 执行任务并获取Future对象  
        Future f = pool.submit(c);  
        // System.out.println(">>>" + f.get().toString());  
        list.add(f);  
       }  
       // 关闭线程池  
       pool.shutdown();  
      
       // 获取所有并发任务的运行结果  
       for (Future f : list) {  
        // 从Future对象上获取任务的返回值,并输出到控制台  
        System.out.println(">>>" + f.get().toString());  
       }  
      
       Date date2 = new Date();  
       System.out.println("----程序结束运行----,程序运行时间【"  
         + (date2.getTime() - date1.getTime()) + "毫秒】");  
    }  
    }  
      
    
    class MyCallable implements Callable<Object> {  
    private String taskNum;  
      
    MyCallable(String taskNum) {  
       this.taskNum = taskNum;  
    }  
      
    public Object call() throws Exception {  
       System.out.println(">>>" + taskNum + "任务启动");  
       Date dateTmp1 = new Date();  
       Thread.sleep(1000);  
       Date dateTmp2 = new Date();  
       long time = dateTmp2.getTime() - dateTmp1.getTime();  
       System.out.println(">>>" + taskNum + "任务终止");  
       return taskNum + "任务返回运行结果,当前任务时间【" + time + "毫秒】";  
    }  
    }  

     

    代码说明:

    上述代码中Executors类,提供了一系列工厂方法用于创建线程池,返回的线程池都实现了ExecutorService接口。

    public static ExecutorService newFixedThreadPool(int nThreads) 
    创建固定数目线程的线程池。
    
    
    
    public static ExecutorService newCachedThreadPool() 
    创建一个可缓存的线程池,调用execute 将重用以前构造的线程(如果线程可用)。如果现有线程没有可用的,则创建一个新线程并添加到池中。
    终止并从缓存中移除那些已有 60 秒钟未被使用的线程。
    

     

    
    public static ExecutorService newSingleThreadExecutor() 
    创建一个单线程化的Executor。
    
    
    
    public static ScheduledExecutorService newScheduledThreadPool(int corePoolSize) 
    创建一个支持定时及周期性的任务执行的线程池,多数情况下可用来替代Timer类。
    
    
    
    ExecutoreService提供了submit()方法,传递一个Callable,或Runnable,返回Future。
    如果Executor后台线程池还没有完成Callable的计算,这调用返回Future对象的get()方法,会阻塞直到计算完成。

     

     

     

     

    展开全文
  • Java线程实现的四种方式

    万次阅读 多人点赞 2017-07-19 01:45:07
    Java线程实现方式有四种 1.继承Thread类,重写run方法 2.实现Runnable接口,重写run方法,实现Runnable接口的实现类的实例对象作为Thread构造函数的target 3.通过Callable和FutureTask创建线程 4.通过线程池创建...

    Java多线程实现的方式有四种

    • 1.继承Thread类,重写run方法
    • 2.实现Runnable接口,重写run方法,实现Runnable接口的实现类的实例对象作为Thread构造函数的target
    • 3.通过Callable和FutureTask创建线程
    • 4.通过线程池创建线程

      前面两种可以归结为一类:无返回值,原因很简单,通过重写run方法,run方式的返回值是void,所以没有办法返回结果
      后面两种可以归结成一类:有返回值,通过Callable接口,就要实现call方法,这个方法的返回值是Object,所以返回的结果可以放在Object对象中

    方式1:继承Thread类的线程实现方式如下:

    public class ThreadDemo01 extends Thread{
        public ThreadDemo01(){
            //编写子类的构造方法,可缺省
        }
        public void run(){
            //编写自己的线程代码
            System.out.println(Thread.currentThread().getName());
        }
        public static void main(String[] args){ 
            ThreadDemo01 threadDemo01 = new ThreadDemo01(); 
            threadDemo01.setName("我是自定义的线程1");
            threadDemo01.start();       
            System.out.println(Thread.currentThread().toString());  
        }
    }

    程序结果:
    Thread[main,5,main]
    我是自定义的线程1

    线程实现方式2:通过实现Runnable接口,实现run方法,接口的实现类的实例作为Thread的target作为参数传入带参的Thread构造函数,通过调用start()方法启动线程

    public class ThreadDemo02 {
    
        public static void main(String[] args){ 
            System.out.println(Thread.currentThread().getName());
            Thread t1 = new Thread(new MyThread());
            t1.start(); 
        }
    }
    
    class MyThread implements Runnable{
        @Override
        public void run() {
            // TODO Auto-generated method stub
            System.out.println(Thread.currentThread().getName()+"-->我是通过实现接口的线程实现方式!");
        }   
    }

    程序运行结果:
    main
    Thread-0–>我是通过实现接口的线程实现方式!

    线程实现方式3:通过Callable和FutureTask创建线程
    a:创建Callable接口的实现类 ,并实现Call方法
    b:创建Callable实现类的实现,使用FutureTask类包装Callable对象,该FutureTask对象封装了Callable对象的Call方法的返回值
    c:使用FutureTask对象作为Thread对象的target创建并启动线程
    d:调用FutureTask对象的get()来获取子线程执行结束的返回值

    public class ThreadDemo03 {
    
        /**
         * @param args
         */
        public static void main(String[] args) {
            // TODO Auto-generated method stub
    
            Callable<Object> oneCallable = new Tickets<Object>();
            FutureTask<Object> oneTask = new FutureTask<Object>(oneCallable);
    
            Thread t = new Thread(oneTask);
    
            System.out.println(Thread.currentThread().getName());
    
            t.start();
    
        }
    
    }
    
    class Tickets<Object> implements Callable<Object>{
    
        //重写call方法
        @Override
        public Object call() throws Exception {
            // TODO Auto-generated method stub
            System.out.println(Thread.currentThread().getName()+"-->我是通过实现Callable接口通过FutureTask包装器来实现的线程");
            return null;
        }   
    }

    程序运行结果:
    main
    Thread-0–>我是通过实现Callable接口通过FutureTask包装器来实现的线程

    线程实现方式4:通过线程池创建线程

    public class ThreadDemo05{
    
        private static int POOL_NUM = 10;     //线程池数量
    
        /**
         * @param args
         * @throws InterruptedException 
         */
        public static void main(String[] args) throws InterruptedException {
            // TODO Auto-generated method stub
            ExecutorService executorService = Executors.newFixedThreadPool(5);  
            for(int i = 0; i<POOL_NUM; i++)  
            {  
                RunnableThread thread = new RunnableThread();
    
                //Thread.sleep(1000);
                executorService.execute(thread);  
            }
            //关闭线程池
            executorService.shutdown(); 
        }   
    
    }
    
    class RunnableThread implements Runnable  
    {     
        @Override
        public void run()  
        {  
            System.out.println("通过线程池方式创建的线程:" + Thread.currentThread().getName() + " ");  
    
        }  
    }  

    程序运行结果:
    通过线程池方式创建的线程:pool-1-thread-3
    通过线程池方式创建的线程:pool-1-thread-4
    通过线程池方式创建的线程:pool-1-thread-1
    通过线程池方式创建的线程:pool-1-thread-5
    通过线程池方式创建的线程:pool-1-thread-2
    通过线程池方式创建的线程:pool-1-thread-5
    通过线程池方式创建的线程:pool-1-thread-1
    通过线程池方式创建的线程:pool-1-thread-4
    通过线程池方式创建的线程:pool-1-thread-3
    通过线程池方式创建的线程:pool-1-thread-2

    ExecutorService、Callable都是属于Executor框架。返回结果的线程是在JDK1.5中引入的新特征,还有Future接口也是属于这个框架,有了这种特征得到返回值就很方便了。
    通过分析可以知道,他同样也是实现了Callable接口,实现了Call方法,所以有返回值。这也就是正好符合了前面所说的两种分类

    执行Callable任务后,可以获取一个Future的对象,在该对象上调用get就可以获取到Callable任务返回的Object了。get方法是阻塞的,即:线程无返回结果,get方法会一直等待。

    再介绍Executors类:提供了一系列工厂方法用于创建线程池,返回的线程池都实现了ExecutorService接口。

    • public static ExecutorService newFixedThreadPool(int nThreads)
      创建固定数目线程的线程池。
    • public static ExecutorService newCachedThreadPool()
      创建一个可缓存的线程池,调用execute 将重用以前构造的线程(如果线程可用)。如果现有线程没有可用的,则创建一个新线程并添加到池中。终止并从缓存中移除那些已有 60 秒钟未被使用的线程。
    • public static ExecutorService newSingleThreadExecutor()
      创建一个单线程化的Executor。
    • public static ScheduledExecutorService newScheduledThreadPool(int
      corePoolSize)
      创建一个支持定时及周期性的任务执行的线程池,多数情况下可用来替代Timer类。
    • ExecutoreService提供了submit()方法,传递一个Callable,或Runnable,返回Future。如果Executor后台线程池还没有完成Callable的计算,这调用返回Future对象的get()方法,会阻塞直到计算完成。
    展开全文
  • Java中线程的三种实现方式

    千次阅读 2016-08-21 22:39:16
    Java中使用Thread代表线程类,所有的线程类都必须是Thread类或者其子类的实例。...Java中线程实现方式有如下三种: 1.继承Thread类 public class Thread extends Object implements Runnable 定义Thread类
  • JAVA线程实现方式主要有三种:继承Thread类、实现Runnable接口、使用ExecutorService、Callable、Future实现有返回结果的多线程。其中前两种方式线程执行完后都没有返回值,只有最后一种是带返回值的。 1、继承...
  • Java线程实现方式详解(Java基础)

    千次阅读 多人点赞 2020-05-29 18:15:48
    你好我是辰兮,很高兴你能来阅读,本篇为Java基础之多线程实现讲解,基础知识的讲解,相关的更多,面试知识已经提前整理好...创建线程方式一致为Java面试常见基础问题,基础学习我们常用前两种方式,下文带大.
  • java线程实现的四种方式

    千次阅读 2018-08-29 11:13:07
    一个线程的生命周期 线程是一个动态执行的过程,它也有一个从产生到死亡的过程。 下图显示了一个线程完整的生命周期。 新建状态: ... 使用 new 关键字和 Thread 类或其...就绪状态的线程处于就绪队列,要...
  • Java线程线程安全实现方式

    万次阅读 2016-06-17 19:38:30
    线程安全就是要保证数据的高度一致性和准确性,但不是一定要加锁才是线程安全性,只要代码里没有变量互串,线程之间互不影响,就是线程安全的。 要了解线程安全,可以先看一下线程不安全是怎样的一种现象。public ...
  • Java线程实现

    千次阅读 2018-10-13 15:43:25
    java中主要提供两种方式现实多线程,它们需要继承java.lang.Thread类或实现java.lang.Runnable接口。 继承Thread类 程序员启动一个新线程需要建立Thread实例,Thread类常用的两个构造方法如下: Public ...
  • Java线程实现方式主要有四种:继承Thread类、实现Runnable接口、实现Callable接口通过FutureTask包装器来创建Thread线程、使用ExecutorService、Callable、Future实现有返回结果的多线程。 1、继承Th...
  • JAVA线程实现Runnable方式

    万次阅读 2011-12-24 15:35:40
    覆盖Runnable接口的run方法,将线程要运行的代码存放在run方法。 3.通过Thread类建立线程对象。 4.将Runnable接口的子类对象作为实际参数传递给Thread类的构造函数。  为什么要讲Runnable接口的子类对象传递...
  • java线程同步的实现方式

    千次阅读 2019-03-08 01:47:21
    这里抛砖引玉,为何要使用同步?...下面总结一些java线程实现同步方式,大致有下面几种: 1.同步方法 使用 synchronized关键字,可以修饰普通方法、静态方法,以及语句块。由于java的每个对象都有一个内置锁...
  • Java线程:实现方式

    千次阅读 2012-03-03 23:49:52
    Java中, 多线程实现有两种方式: 扩展java.lang.Thread类 实现java.lang.Runnable接口 方法1 /** * @Description: 继承Thread类, 实现线程. * @author snoopy * @blog http://blog.csdn.net/huang_xw ...
  • Java线程的4种实现方式详解以及案例演示

    千次阅读 多人点赞 2020-03-11 23:08:55
    介绍了Java线程的4种实现方式:继承Thread、实现Runnable、实现Callable、使用线程池。
  •  在子类重新实现父类的run()方法,然后在使用多线程的时候调用start()方法,则系统会自动调用run()方法。 实现类: package com.ysu.test; public class Thread1 extends Thread{ private String name; ...
  • java线程实现的几种方式

    千次阅读 2019-01-29 13:43:30
    1.通过继承Thread类实现 public class MyThread extends Thread{ public void run(){ System.out.println(&amp;amp;quot;New Thread : &amp;amp;quot;+Thread.currentThread().getName()); } public ...
  • java线程和多线程实现方式

    千次阅读 2018-07-31 16:51:05
    注:此文章引用于 ... 1. java线程实现  一个任务一个人独立完成 public class SingletonThread {  @SuppressWarnings("static-access")  public static void mai...
  • Java线程的4种实现方式

    万次阅读 2019-04-12 07:48:57
    Java线程的4种实现方式 1:继承Thread并重写run方法,并调用start方法 /** * Java实现线程方式1 * 继承Thread类,重写run方法 * @author hongbo.zhao 2019年4月12日 上午7:12:35 */ class MyThread ...
  • java线程编程】三种多线程实现方式

    万次阅读 多人点赞 2019-01-01 16:20:56
    文章目录前言进程与线程继承Thread类,实现线程FAQ 为什么多线程的启动不直接使用run()方法而必须使用Thread类start()方法呢?基于Runnable接口实现线程Thread 与 Runnable 的关系Callable实现线程线程...
  • java中实现线程及同步方式

    千次阅读 2018-05-22 14:46:21
    线程实现方式 1)、实现Runnable接口,并实现run()方法 以下是主要步骤: 1、自定义类并实现Runnable接口,并实现run()方法。 2、创建Thread对象,用实现Runnable接口的对象作为参数实例化该Thread对象。 3...
  • java实现线程通信的几种方式

    千次阅读 2020-05-30 19:34:35
    比如大家熟知的消息中间件的实现,从某种角度上讲,就借助了多线程通信的思想,下面总结了JDK常用的几种实现线程通信的方式,提供参考 1、synchronized实现方式 可能很多小伙伴们会有疑问,synchronized是对共享...
  • 万字图解Java线程

    万次阅读 多人点赞 2020-09-06 14:45:07
    java线程我个人觉得是javaSe最难的一部分,我以前也是感觉学会了,但是真正有多线程的需求却不知道怎么下手,实际上还是对多线程这块知识了解不深刻,不知道多线程api的应用场景,不知道多线程的运行流程等等,...
  • Java:简述Java线程的四种实现方式

    千次阅读 2018-06-04 00:12:01
    Java线程实现方式主要有四种:继承Thread类、实现Runnable接口、实现Callable接口通过FutureTask包装器来创建Thread线程、使用线程池接口ExecutorService结合Callable、Future实现有返回结果的多线程。 其中前两...
  • java线程实现的两种方式

    千次阅读 2018-04-18 10:39:28
    java自带主要有两种实现线程方式。第一种:继承线程类Thread,重新run的方法。第二种:实现接口Runnable,重新run方法。我先不说明他们的区别。先看代码的实现。第一种方式:public class MyThread extends ...
  • java线程的6种实现方式详解

    万次阅读 多人点赞 2017-10-12 12:41:57
    线程的形式上实现方式主要有两种,一种是继承Thread类,一种是实现Runnable接口。本质上实现方式都是来实现线程任务,然后启动线程执行线程任务(这里的线程任务实际上就是run方法)。这里所说的6种,实际上都是在...
  • Java线程实现复制文件

    千次阅读 2018-09-24 15:55:33
    * 多线程实现文件从一个目录复制到另一个目录 * @param sourceFile:给定源文件路径名 * @param desPath:复制点文件路径 * @return */ 代码实现如下: package com.tulun.thread; import java.io.File; import...
  • * 多线程实现方式一 :继承Tread类,并重写run方法,创建实例调用start方法 */ public class TestTread extends Thread{ //idea快速重现父类方法的快捷键是 ctrl + o @Override public void run() { ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 1,051,317
精华内容 420,526
关键字:

java中线程的实现方式

java 订阅