多线程实现的四种方式_实现多线程的四种方式 - CSDN
精华内容
参与话题
  • java有以下四种创建多线程方式: 1:继承Thread类创建线程 2:实现Runnable接口创建线程 3:使用Callable和FutureTask创建线程 4:使用线程池,例如用Executor框架创建线程 DEMO代码: package thread; ...

    java有以下四种创建多线程的方式

    • 1:继承Thread类创建线程

    • 2:实现Runnable接口创建线程

    • 3:使用Callable和FutureTask创建线程

    • 4:使用线程池,例如用Executor框架创建线程

    DEMO代码

    package thread;
     
    import java.util.concurrent.*;
     
    
    public class ThreadTest {
        public static void main(String[] args) throws ExecutionException, InterruptedException {
    //      创建线程的第一种方法
            Thread1 thread1 = new Thread1();
            thread1.start();
     
    //      创建线程的第二种方法
            Thread2 thread2 = new Thread2();
            Thread thread = new Thread(thread2);
            thread.start();
     
    //      创建线程的第三种方法
            Callable<String> callable = new Thread3();
            FutureTask<String> futureTask = new FutureTask<>(callable);
            Thread thread3 = new Thread(futureTask);
            thread3.start();
            String s = futureTask.get();
            System.out.println(s);
     
    //      创建线程的第四种方法
            Executor executor = Executors.newFixedThreadPool(5);
            executor.execute(new Runnable() {
                @Override
                public void run() {
                    System.out.println(Thread.currentThread()+"创建线程的第四种方法");
                }
            });
            ((ExecutorService) executor).shutdown();
     
        }
    }
    class Thread1 extends Thread{
        @Override
        public void run() {
            System.out.println(Thread.currentThread()+"创建线程的第一种方法");
        }
    }
     
    class Thread2 implements Runnable {
     
        @Override
        public void run() {
            System.out.println(Thread.currentThread()+"创建线程的第二种方法");
        }
    }
     
    class Thread3 implements Callable<String> {
     
        @Override
        public String call() throws Exception {
            return Thread.currentThread()+"创建线程的第三种方法";
        }
    }
    
    

    创建线程的三种方式的对比

    1、采用实现Runnable、Callable接口的方式创建多线程

      优势:
    
       线程类只是实现了Runnable接口或Callable接口,还可以继承其他类。
    
       在这种方式下,多个线程可以共享同一个target对象,所以非常适合多个相同线程来处理同一份资源的情况,从而可以将CPU、代码和数据分开,形成清晰的模型,较好地体现了面向对象的思想。
    
       劣势:
    
     编程稍微复杂,如果要访问当前线程,则必须使用Thread.currentThread()方法。
    

    2、使用继承Thread类的方式创建多线程

      优势:
    
      编写简单,如果需要访问当前线程,则无需使用Thread.currentThread()方法,直接使用this即可获得当前线程。
    
      劣势:
    
      线程类已经继承了Thread类,所以不能再继承其他父类。
    

    3、Runnable和Callable的区别

    Runnable接口定义的run方法,Callable定义的是call方法。
    run方法没有返回值,call方法必须有返回值。
    run方法无法抛出异常,call方法可以抛出checked exception。
    Callable和Runnable都可以应用于executors。而Thread类只支持Runnable.
    

    总结

    鉴于上面分析,因此一般推荐采用实现Runnable接口、Callable接口的方式来创建多线程。

    如果大家对java架构相关感兴趣,可以关注下面公众号,会持续更新java基础面试题, netty, spring boot,spring cloud等系列文章,一系列干货随时送达, 超神之路从此展开, BTAJ不再是梦想!

    架构殿堂

    展开全文
  • 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多线程实现方式主要有四种:继承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()方法,会阻塞直到计算完成。

    软件-注重思想、逻辑

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

    万次阅读 2018-07-31 16:52:46
    实现多线程有以下四种方式: 1. 继承Thread类 2.实现Runnable接口 3.实现Callable接口 4.线程池:提供了一个线程队列,队列中保存着所有等待状态的线程。避免了创建与销毁额外开销,提高了响应的速度。 体系...

    实现多线程有以下四种方式:

    1. 继承Thread类

    2.实现Runnable接口

    3.实现Callable接口

    4.线程池:提供了一个线程队列,队列中保存着所有等待状态的线程。避免了创建与销毁额外开销,提高了响应的速度。

    体系结构:

    java.util.concurrent.Executor : 负责线程的使用与调度的根接口
             |--ExecutorService 子接口: 线程池的主要接口
                   |--ThreadPoolExecutor 线程池的实现类
                   |--ScheduledExecutorService 子接口:负责线程的调度
                       |--ScheduledThreadPoolExecutor :继承 ThreadPoolExecutor, 实现 ScheduledExecutorService *

    工具类 : Executors 
          ExecutorService newFixedThreadPool() : 创建固定大小的线程池
          ExecutorService newCachedThreadPool() : 缓存线程池,线程池的数量不固定,可以根据需求自动的更改数量。
          ExecutorService newSingleThreadExecutor() : 创建单个线程池。线程池中只有一个线程
          ScheduledExecutorService newScheduledThreadPool() : 创建固定大小的线程,可以延迟或定时的执行任务。

     

    1) 继承Thread类

    package com.lxj.juc;
    
    public class TestThread {
         public static void main(String[] args) {
        	 ThreadDemo threadDemo = new ThreadDemo();
        	 threadDemo.start();
    	 }
    }
    
    
    class  ThreadDemo extends Thread{
    
    	@Override
    	public void run() {
    	    boolean flag = false;
    		for(int i  = 3 ; i < 100 ; i ++) {
    			flag = false;
    			for(int j = 2; j <= Math.sqrt(i) ; j++) {
    				if(i % j == 0) {
    					flag = true;
    					break;
    				}
    			}
    			if(flag == false) {
    				System.out.print(i+"  ");
    			}
    		}
    	}
      
    	 
    }
    运行结果:
    3  5  7  11  13  17  19  23  29  31  37  41  43  47  53  59  61  67  71  73  79  83  89  97  

    2)实现Runnable接口

    package com.lxj.juc;
    
    public class TestRunnable {
        public static void main(String[] args) {
    		RunnableDemo runnableDemo = new RunnableDemo();
    		new Thread(runnableDemo).start();
    	}
    }
    
    class RunnableDemo implements Runnable{
    
    	@Override
    	public void run() {
    		boolean flag = false;
    		for(int i  = 3 ; i < 100 ; i ++) {
    			flag = false;
    			for(int j = 2; j <= Math.sqrt(i) ; j++) {
    				if(i % j == 0) {
    					flag = true;
    					break;
    				}
    			}
    			if(flag == false) {
    				System.out.print(i+"  ");
    			}
    		}
    	}
    	
    }
    运行结果:
    3  5  7  11  13  17  19  23  29  31  37  41  43  47  53  59  61  67  71  73  79  83  89  97  

    3)实现Callable接口

    package com.lxj.juc;
    
    import java.util.ArrayList;
    import java.util.List;
    import java.util.concurrent.Callable;
    import java.util.concurrent.ExecutionException;
    import java.util.concurrent.Executors;
    import java.util.concurrent.FutureTask;
    
    public class TestCallable1 {
        public static void main(String[] args) throws InterruptedException, ExecutionException {
        	CallableDemo callableDemo = new CallableDemo();
        	FutureTask futureTask = new FutureTask<>(callableDemo); 
        	new Thread(futureTask).start();
        	List<Integer> lists = (List<Integer>)futureTask.get(); //获取返回值
        	for (Integer integer : lists) {
    			System.out.print(integer + "  ");
    		}
    	}
    }
    
    class CallableDemo implements Callable<List<Integer>>{
    
    	@Override
    	public List<Integer> call() throws Exception {
    		boolean flag = false;
    		List<Integer> lists = new ArrayList<>();
    		for(int i  = 3 ; i < 100 ; i ++) {
    			flag = false;
    			for(int j = 2; j <= Math.sqrt(i) ; j++) {
    				if(i % j == 0) {
    					flag = true;
    					break;
    				}
    			}
    			if(flag == false) {
    				lists.add(i);
    			}
    		}
    		return lists;
    	}
    	
    }
    运行结果:
    3  5  7  11  13  17  19  23  29  31  37  41  43  47  53  59  61  67  71  73  79  83  89  97  

    4) 线程池

    package com.lxj.juc;
    
    import java.util.ArrayList;
    import java.util.List;
    import java.util.concurrent.Callable;
    import java.util.concurrent.ExecutionException;
    import java.util.concurrent.ExecutorService;
    import java.util.concurrent.Executors;
    import java.util.concurrent.Future;
    
    public class TestThreadPool {
    	public static void main(String[] args) throws InterruptedException, ExecutionException {
    		ExecutorService executorService = Executors.newFixedThreadPool(5);
    		List<Future<List<Integer>>> ints = new ArrayList<>();
    		for(int i = 0 ; i < 5; i ++) {
    			Future<List<Integer>> future = executorService.submit(new Callable<List<Integer>>() {
    				@Override
    				public List<Integer> call() throws Exception {
    					boolean flag = false;
    					System.out.println(Thread.currentThread().getName()+"  ");
    					List<Integer> lists = new ArrayList<>();
    					for(int i  = 3 ; i < 100 ; i ++) {
    						flag = false;
    						for(int j = 2; j <= Math.sqrt(i) ; j++) {
    							if(i % j == 0) {
    								flag = true;
    								break;
    							}
    						}
    						if(flag == false) {
    							lists.add(i);
    						}
    					}
    					return lists;
    				}
    			});
    			ints.add(future);
    		}
    		
    		for (Future<List<Integer>> future : ints) {
    			System.out.println(future.get());
    		}
    	}
    }
    
    class ThreadPoolDemo {
    
    }
    运行结果:
    pool-1-thread-2  
    pool-1-thread-5  
    pool-1-thread-3  
    pool-1-thread-1  
    pool-1-thread-4  
    [3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97]
    [3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97]
    [3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97]
    [3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97]
    [3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97]
    

    以上即为创建多线程的4种方式。

     

     

     

     

    展开全文
  • 多线程的几种实现方式

    万次阅读 2019-02-25 15:33:38
    上篇文章总结了下关于线程池很干,很干的干货,这次想着顺便连其他实现多线程的三种方式也汇总下吧! java多线程的几种实现方式: 1.继承Thread类,重写run方法 2.实现Runnable接口,重写run方法,实现Runnable...
  • python多线程交替打印abc

    千次阅读 2019-03-21 17:48:05
    利用python线程的互斥锁可以把资源锁住,然后一个时间只让一个线程执行 关于缓冲区问题:使用 print 输出时会先把数据放到缓冲区里,只有当程序结束时或缓冲区遇到 \n 时,才将数据显示到屏幕,并清空缓冲区,而 ...
  • Java:简述Java多线程四种实现方式

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

    千次阅读 2018-08-29 11:13:07
    一个线程的生命周期 线程是一个动态执行的过程,它也有一个从产生到死亡的过程。 下图显示了一个线程完整的生命周期。 新建状态: 使用 new 关键字和 Thread 类或其子类建立一个线程对象后,该线程对象就...
  • .net 多线程四种实现方式

    千次阅读 2019-08-01 15:19:23
    .net中创建多线程可以有四种方式: Thread类、委托、ThreadPool类、Task类 Thread类创建多线程 /// <summary> /// Thread类启动 /// </summary> public static void Thread_Start() { ...
  • java多线程的6种实现方式详解

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

    万次阅读 多人点赞 2020-02-17 23:32:54
    本文我们来看看多线程的应用场景,为什么要用多线程,以及实现一个多线程有几种方式
  • Java多线程实现方式主要有四种:继承Thread类、实现Runnable接口、实现Callable接口通过FutureTask包装器来创建Thread线程、使用ExecutorService、Callable、Future实现有返回结果的多线程。 1、继承Th...
  • java创建多线程四种方式及其区别

    千次阅读 2019-04-26 18:35:25
    java创建多线程有如下四种方式: 继承Thread类创建线程 实现Runnable接口创建线程 使用Callable和Future创建线程 使用线程池创建(使用java.util.concurrent.Executor接口) 下面分别介绍这四种创建多线程方式...
  • 多线程面试题(值得收藏)

    万次阅读 多人点赞 2019-08-16 09:41:18
    史上最强多线程面试47题(含答案),建议收藏 金九银十快到了,即将进入找工作的高峰期,最新整理的最全多线程并发面试47题和答案总结,希望对想进BAT的同学有帮助,由于篇幅较长,建议收藏后细看~ 1、并发编程三要素?...
  • 创建多线程四种方式

    千次阅读 2019-06-18 09:25:49
    创建多线程共有四种方式: 继承Thread类创建多线程 实现Runnable接口创建多线程 实现Callable接口通过FutureTask包装器来创建Thread多线程 使用ExecutorService、Callable、Future实现有返回结果的线程。 1. 继承...
  • Python进阶(二十六)-多线程实现同步的四种方式  临界资源即那些一次只能被一个线程访问的资源,典型例子就是打印机,它一次只能被一个程序用来执行打印功能,因为不能多个线程同时操作,而访问这部分资源的代码...
  • ios多线程开发的常用四种方式 1. pthread 2. NSThread 3. NSOperation\NSOperationQueue 4. GCD 一 、pthread C语言通用的多线程API,跨平台,程序员手动管理线程生命周期,使用难度大 代码实现 //创建线程 NSLog...
  • 多线程实现同步的七种方式

    千次阅读 2017-11-15 19:43:55
    JAVA中线程同步的方法(7)汇总 同步的方法: 一、同步方法  即有synchronized关键字修饰的方法。 由于java的每个对象都有一个内置锁,当用此关键字修饰方法时, 内置锁会保护整个方法。在调用该方法前...
  • 线程创建的四种方式

    万次阅读 多人点赞 2018-03-30 14:34:14
    Java可以用四种方式来创建线程,如下所示: 1)继承Thread类创建线程 2)实现Runnable接口创建线程 3)使用Callable和Future创建线程 4)使用线程池例如用Executor框架 下面让我们分别来看看这四种创建线程的...
  • java 创建线程的三种方式、创建线程池的四种方式

    万次阅读 多人点赞 2019-02-23 21:01:44
    概要: java创建线程的三种方式: ...java创建线程池的四种方式: newCachedThreadPool 创建一个可缓存的线程池,如果线程池长度超过处理需求,可灵活回收空闲线程,若无可回收,则新建线程 newFixedThread...
1 2 3 4 5 ... 20
收藏数 377,110
精华内容 150,844
关键字:

多线程实现的四种方式