创建多线程的四种方式

Posted 2022-02-10 学僧ceo

注：主要记录创建的步骤，代码仅供参考

方式一：继承Thread

/**
 * 创建多线程方式一：继承Thread
 * 1：创建一个继承于Thread类的子类
 * 2：重写Thread类的run()
 * 3：创建Thread类的子类对象
 * 4：通过此对象调用start()
 */
public class ThreadTestOne 
    public static void main(String[] args) 
        MyThread myThread1 = new MyThread();
        MyThread myThread2 = new MyThread();
        myThread1.start();
        myThread2.start();
        for (int i = 0; i < 100; i++) 
            System.out.println(Thread.currentThread().getName() + ":" + i);
        
    


class MyThread extends Thread 
    @Override
    public void run() 
        for (int i = 1; i <= 100; i++) 
            if (i % 2 == 0) 
                System.out.println(Thread.currentThread().getName() + ":" + i);
            
        
    

方式二：实现Runnable接口

/**
 * 创建多线程的方式二：实现Runnable接口
 * 1:创建一个实现了Runnable接口的类
 * 2：实现类去实现Runnable中的抽象方法：run()
 * 3:创建实现类的对象
 * 4：将此对象作为参数传递到Thread类的构造器中，创建Thread类的对象
 * 5：通过Thread类的对象调用start()
 */
public class ThreadTestTwo 
    public static void main(String[] args) 
        MThread mThread = new MThread();
        Thread thread = new Thread(mThread);
        thread.setName("进程一");
        thread.start();
        Thread thread2 = new Thread(mThread);
        thread2.setName("进程二");
        thread2.start();
    


class MThread implements Runnable 
    @Override
    public void run() 
        for (int i = 0; i < 100; i++) 
            if (i % 2 == 0) 
                System.out.println(Thread.currentThread().getName() + ":" + i);
            
        
    

方式三：实现Callable接口

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;

/**
 * 多线程创建方式之三：实现Callable接口。jdk5.0新增
 * 1：创建一个实现Callable的实现类
 * 2：实现call方法，将此线程需要执行的操作声明在call方法中
 * 3：创建Callable接口实现类的对象
 * 4：将此Callable接口实现类的对象作为参数传递到FutureTask构造器中，创建FutureTask的对象
 * 5：将FutureTask的对象作为参数传递到Thread类的构造器中，创建Thread对象并调用start()
 * 6：使用FutureTask的get方法获取Callable中call方法的返回值（可不获取）
 */
public class ThreadTestThree 
    public static void main(String[] args) throws ExecutionException, InterruptedException 
        ThirdThread thirdThread = new ThirdThread();
        FutureTask futureTask = new FutureTask(thirdThread);
        Thread thread = new Thread(futureTask);
        thread.setName("线程一");
        thread.start();
        for (int i = 1; i <= 100; i++) 
            if (i % 2 != 0) 
                System.out.println(Thread.currentThread().getName() + ":" + i);
            
        

        Object o = futureTask.get();
        System.out.println(Thread.currentThread().getName() + ": 线程一总和为" + o);
    


class ThirdThread implements Callable 
    @Override
    public Object call() throws Exception 
        int sum = 0;
        for (int i = 1; i <= 100; i++) 
            if (i % 2 == 0) 
                System.out.println(Thread.currentThread().getName() + ":" + i);
                sum += i;
            
        
        return sum;
    

方式四：线程池

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.ThreadPoolExecutor;

/**
 * 创建多线程方式之四：线程池
 * 1：提供线程池
 * 2：执行指定的线程操作，需提供Runnable或Callable的实现类对象
 * 3：关闭线程池
 */
public class ThreadTestFour 
    public static void main(String[] args) 
        ExecutorService executorService = Executors.newFixedThreadPool(10);
        //获取接口的实现类型
        //System.out.println(executorService.getClass());
        ThreadPoolExecutor threadPoolExecutor = (ThreadPoolExecutor) executorService;
        //设置线程池的属性
        threadPoolExecutor.setCorePoolSize(12);
        threadPoolExecutor.setMaximumPoolSize(10);
        /**
         * executorService.execute(Runnable commd);
         * executorService.submit(Callable commd)：可用FutureTask获取结果;
         */
        executorService.submit(new ThreadTest());
        executorService.submit(new ThreadTest());
        executorService.shutdown();
    


class ThreadTest implements Callable 
    @Override
    public Object call() throws Exception 
        int sum = 0;
        for (int i = 1; i <= 100; i++) 
            if (i % 2 == 0) 
                System.out.println(Thread.currentThread().getName() + ":" + i);
                sum += i;
            
        
        return sum;
    

 例：三个窗口同时售票

public class ThreadRunnableLearn 
    public static void main(String[] args) 
        RunnableThread runnableThread = new RunnableThread();
        Thread thread1 = new Thread(runnableThread);
        thread1.setName("窗口一");
        Thread thread2 = new Thread(runnableThread);
        thread2.setName("窗口二");
        Thread thread3 = new Thread(runnableThread);
        thread3.setName("窗口三");
        thread1.start();
        thread2.start();
        thread3.start();
    


class RunnableThread implements Runnable 
    private int ticket = 100;

    @Override
    public void run() 
        while (true) 
            /**
             * 解决线程安全问题有三种方式:
             * 一：同步代码块（如例），RunnableThread类也是一个对象，而且只会加载一次，所以是唯一的
             * 二：同步方法【private synchronized void 方法名() 】当操作共享数据的代码在一个方法中，则可使用
             * 当同步方法为非静态：则默认同步监视器是this
             * 当同步方法为静态: 则默认同步监视器是该方法属于的类 xxx.class
             * 三：ReentrantLock
             */
            synchronized (RunnableThread.class) 
                if (ticket > 0) 
                    try 
                        Thread.sleep(100);
                     catch (InterruptedException e) 
                        e.printStackTrace();
                    
                    System.out.println(Thread.currentThread().getName() + "售票，票号为" + ticket);
                    ticket--;
                else 
                    break;