Java创建线程的方式

小灰灰 2023-10-04 19:39 26阅读 0赞

### 创建线程的方式 ###

在JDK1.5之前，创建线程就只有两种方式，即继承java.lang.Thread类和实现java.lang.Runnable接口；而在JDK1.5以后，增加了两个创建线程的方式，即实现java.util.concurrent.Callable接口和线程池。下面是这4种方式创建线程的代码实现。

#### 1、继承Thread类 ####

//继承Thread类来创建线程
    public class ThreadTest {
        
     
        public static void main(String[] args) {
        
            //设置线程名字
            Thread.currentThread().setName("main thread");
            MyThread myThread = new MyThread();
            myThread.setName("子线程:");
            //开启线程
            myThread.start();
            for(int i = 0;i<5;i++){
        
                System.out.println(Thread.currentThread().getName() + i);
            }
        }
    }
     
    class MyThread extends Thread{
        
        //重写run()方法
        public void run(){
        
            for(int i = 0;i < 10; i++){
        
                System.out.println(Thread.currentThread().getName() + i);
            }
        }
    }

#### 2、实现Runnable接口 ####

//实现Runnable接口
    public class RunnableTest {
        
      
        public static void main(String[] args) {
        
            //设置线程名字
            Thread.currentThread().setName("main thread:");
            Thread thread = new Thread(new MyRunnable());
            thread.setName("子线程:");
            //开启线程
            thread.start();
            for(int i = 0; i <5;i++){
        
                System.out.println(Thread.currentThread().getName() + i);
            }
        }
    }
      
    class MyRunnable implements Runnable {
        
      
        @Override
        public void run() {
        
            for (int i = 0; i < 10; i++) {
        
                System.out.println(Thread.currentThread().getName() + i);
            }
        }
    }

#### 3、实现Callable接口 ####

import java.util.concurrent.Callable;
    import java.util.concurrent.ExecutionException;
    import java.util.concurrent.FutureTask;
    //实现Callable接口
    public class CallableTest {
        
     
        public static void main(String[] args) {
        
            //执行Callable 方式，需要FutureTask 实现实现，用于接收运算结果
            FutureTask<Integer> futureTask = new FutureTask<Integer>(new MyCallable());
            new Thread(futureTask).start();
            //接收线程运算后的结果
            try {
        
                Integer sum = futureTask.get();
                System.out.println(sum);
            } catch (InterruptedException e) {
        
                e.printStackTrace();
            } catch (ExecutionException e) {
        
                e.printStackTrace();
            }
        }
    }
     
    class MyCallable implements Callable<Integer> {
        
     
        @Override
        public Integer call() throws Exception {
        
            int sum = 0;
            for (int i = 0; i < 100; i++) {
        
                sum += i;
            }
            return sum;
        }
    }

#### 4、线程池 ####

import java.util.concurrent.ExecutorService;
    import java.util.concurrent.Executors;
    //线程池实现
    public class ThreadPoolExecutorTest {
        
     
        public static void main(String[] args) {
        
            //创建线程池
            ExecutorService executorService = Executors.newFixedThreadPool(10);
            ThreadPool threadPool = new ThreadPool();
            for(int i =0;i<5;i++){
        
                //为线程池分配任务
                executorService.submit(threadPool);
            }
            //关闭线程池
            executorService.shutdown();
        }
    }
     
    class ThreadPool implements Runnable {
        
     
        @Override
        public void run() {
        
            for(int i = 0 ;i<10;i++){
        
                System.out.println(Thread.currentThread().getName() + ":" + i);
            }
        }
    
    }