多线程面试题

Java中多线程实现方式？

继承Thread类，重新run方法

//1,定义一个线程类继承Thread类
public class MyThread extends Thread{
    //2,重写run方法
    @Override
    public void run() {
        for (int i = 0; i < 5; i++) {
            System.out.println("子线程执行输出" + i);
        }
    }
}

public class ThreadTest {
    public static void main(String[] args) {
        //3,new一个线程对象
        Thread t1 = new MyThread();
        //4,调用start方法启动线程（执行的是run方法）
        t1.start();
    }
}

实现Runnable接口，重新run方法

//1,定义一个线程任务类,实现Runnable接口
class MyRunnable implements Runnable{
    //2,重写run方法,定义线程执行的任务
    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            System.out.println("子线程执行输出 " + i);
        }
    }
}

public class RunnableTest {
    public static void main(String[] args) {
        //3,创建一个任务对象
        Runnable target = new MyRunnable();
        //4,把任务对象交给thread处理
        Thread thread = new Thread(target);
        //5,启动线程
        thread.start();
    }
}

实现Callable接口，重写call方法，带有返回值

//线程创建方式三：
//1,定义一个任务类   实现Callable接口    申明线程任务执行完毕后的结果类型
class MyCallable implements Callable<String>{
    //2,重写call方法（任务方法）
    @Override
    public String call() {
        int sum = 0;
        for (int i = 0; i < 10; i++) {
            sum += i;
        }
        return "sum= "+sum;
    }
}
    
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;

public class CallableTest {
    public static void main(String[] args) {
        //3,创建Callable任务对象
        Callable callable = new MyCallable();
        //4,把Callable任务对象，交给FutureTask对象
        //FutureTask对象的作用1：FutureTask实现了Runnable接口，可以交给Thread
        //FutureTask对象的作用2：线程执行完可以通过调用get方法得到线程执行结果
        FutureTask futureTask = new FutureTask(callable);
        //5,交给线程处理
        Thread thread = new Thread(futureTask);
        //6,启动线程
        thread.start();
        try {
            String result = (String) futureTask.get();
            System.out.println(result);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
    }
}

线程池

线程池–Runnable方式

import java.util.concurrent.*;

public class ThreadPoolRunnable {
    public static void main(String[] args) {
        /**
         *int corePoolSize主线程个数:正式工,
         *int maximumPoolSize最大线程个数:正式工+临时工,
         *long keepAliveTime临时工工作完多久释放,
         *TimeUnit unit时间单位,
         *BlockingQueue<Runnable> workQueue工作队列:等待区线程最大个数,也就是最多几个任务在等待被线程执行,
         *ThreadFactory threadFactory线程工厂hr,
         *RejectedExecutionHandler handler拒绝策略
         */
        ExecutorService pool = new ThreadPoolExecutor(3,5,5, TimeUnit.SECONDS
                ,new ArrayBlockingQueue<>(6)
                ,Executors.defaultThreadFactory()
                ,new ThreadPoolExecutor.AbortPolicy());
        for (int i = 1; i <= 11; i++) {
            pool.execute(new MyRunnable());
        }
        //rejected from java.util.concurrent.ThreadPoolExecutor@135fbaa4[Running, pool size = 5, active threads = 5, queued tasks = 6, completed tasks = 0]
        //at java.util.concurrent.ThreadPoolExecutor$AbortPolicy.rejectedExecution(ThreadPoolExecutor.java:2063)
        //最大线程容量5+最大等待线程数量6，so，当线程数量>11时，就会报出来
    }
}

class MyRunnable implements Runnable{
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName()+"正在执行");
    }
}

线程池–Callable方式

import java.util.concurrent.*;

public class ThreadPoolCallable {
    public static void main(String[] args) {
        /**
        *int corePoolSize,
        *int maximumPoolSize,
        *long keepAliveTime,
        *TimeUnit unit,
        *BlockingQueue<Runnable> workQueue,
        *ThreadFactory threadFactory,
        *RejectedExecutionHandler handler
        */
        ExecutorService pool = new ThreadPoolExecutor(3,5,5, TimeUnit.SECONDS
                ,new ArrayBlockingQueue<>(6)
                ,Executors.defaultThreadFactory()
                ,new ThreadPoolExecutor.AbortPolicy());
        //线程池去执行线程，返回Future对象
        Future<String> future1 = pool.submit(new MyCallable(5));
        Future<String> future2 = pool.submit(new MyCallable(6));
        Future<String> future3 = pool.submit(new MyCallable(7));
        try {
            //返回线程返回值
            System.out.println(future1.get());
            System.out.println(future2.get());
            System.out.println(future3.get());
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
    }
}

class MyCallable implements Callable<String> {
    private int n;
    public MyCallable(int n) {
        this.n = n;
    }
    @Override
    public String call() {
        int sum = 0;
        for (int i = 0; i < n; i++) {
            sum+=i;
        }
        return Thread.currentThread().getName()+",0~"+n+";sum = "+sum;
    }
}