Java线程和线程池

墨蓝 2021-12-10 13:27 454阅读 0赞

创建线程的方式：继承Thread   、 实现Runnable接口  、实现Callable接口（可以通过Future获取返回结果）

介绍一下通过Callable实现多线程：

public class ThreadC implements Callable {
        public Object call() throws Exception {
            System.out.println("线程执行");
            return "线程返回结果";
        }
    
        public static void main(String []args){
            ThreadC threadC=new ThreadC();
            FutureTask futureTask=new FutureTask(threadC);
            new Thread(futureTask).start();
            try {
                Object  obj=futureTask.get();
                System.out.println(obj);
            } catch (InterruptedException e) {
                e.printStackTrace();
            } catch (ExecutionException e) {
                e.printStackTrace();
            }
        }
    }
    //输出结果
    线程执行
    线程返回结果

线程之间的状态转换（线程的状态：创建  就绪   执行   阻塞   终止）

![20150309140927553][]

对于线程中常用的方法有：  
sleep():当前线程休眠，但对象锁保持不放  
wait():，通常在和notify()一起作用在synchronized方法中，在执行完后让线程进入等待队列  
notify:唤醒在此对象监听器的线程，如果有多个则随机唤醒一个  
yeild():线程让步，暂停当前线程，让同级或更高优先级线程执行  
join():当前线程进入阻塞，等待其他线程终止  
interrupt():中断线程信号

线程同步:     
线程的特点 ：可见性  有序性   在不同步处理情况下多个线程并发执行的时候造成执行顺序随机，变量数据不可靠

public class ThreadD\{  
    public  /\*synchronized \*/ void  print(String name)\{     //传入字符串，按字符输出  
        for(int i=0;i<name.length();i++)\{  
            System.out.print(name.charAt(i));  
        \}  
    \}  
    public  static void main(String \[\]args)\{  
        final ThreadD threadD=new ThreadD();  
             Thread a=new Thread(new Runnable() \{                   //创建两个线程执行print()方法，预期输出lisizhangsan，不在print方法加synchronized时输出结果就会变得随机  
                 public void run() \{  
                     threadD.print("lisi");  
                 \}  
             \});  
        Thread b=new Thread(new Runnable() \{  
            public void run() \{  
                threadD.print("zhangsan");  
            \}  
        \});  
             a.start();  
             b.start();  
    \}

synchronized关键字的作用域有二种：   
1）是某个对象实例内，synchronized aMethod()\{\}可以防止多个线程同时访问这个对象的synchronized方法（如果一个对象有多个synchronized方法，只要一个线程访问了其中的一个synchronized方法，其它线程不能同时访问这个对象中任何一个synchronized方法）。这时，不同的对象实例的synchronized方法是不相干扰的。也就是说，其它线程照样可以同时访问相同类的另一个对象实例中的synchronized方法；   
2）是某个类的范围，synchronized static aStaticMethod\{\}防止多个线程同时访问这个类中的synchronized static 方法。它可以对类的所有对象实例起作用。

2、除了方法前用synchronized关键字，synchronized关键字还可以用于方法中的某个区块中，表示只对这个区块的资源实行互斥访问。用法是: synchronized(this)\{/\*区块\*/\}，它的作用域是当前对象；

3、synchronized关键字是不能继承的，也就是说，基类的方法synchronized f()\{\} 在继承类中并不自动是synchronized f()\{\}，而是变成了f()\{\}。继承类需要你显式的指定它的某个方法为synchronized方法；

该部分文字引入来源:  原文：https://blog.csdn.net/evankaka/article/details/44153709

如何启动三个线程按顺序打印ABC:

public class ThreadB  implements Runnable{
        private String name;
        private Object pre;
        private Object self;
        public ThreadB(String name, Object pre, Object self) {
            this.name = name;
            this.pre = pre;
            this.self = self;
        }
    
        public void run() {
            synchronized (pre){
                synchronized (self){
                    System.out.println(name);
                        self.notify();
                }
                try {
                    pre.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
        public static void main(String []args){
            Object a=new Object();
            Object b=new Object();
            Object c=new Object();
            ThreadB ta=new ThreadB("A",b,c);
            ThreadB tb=new ThreadB("B",c,a);
            ThreadB tc=new ThreadB("C",a,b);
            for(int i=0;i<10;i++){
                new Thread(ta).start();
                new Thread(tb).start();
                new Thread(tc).start();
            }
        }
    }

线程池原理  
public ThreadPoolExecutor(int corePoolSize,  
                               int maximumPoolSize,  
                               long keepAliveTime,  
                               TimeUnit unit,  
                               BlockingQueue<Runnable> workQueue,  
                               RejectedExecutionHandler handler)

corePoolSize：线程池核心线程数量

maximumPoolSize:线程池最大线程数量

keepAliverTime：当活跃线程数大于核心线程数时，空闲的多余线程最大存活时间

unit：存活时间的单位

workQueue：存放任务的队列

handler：超出线程范围和队列容量的任务的处理程序

线程池的实现原理  文字引入来源： [https://www.cnblogs.com/dongguacai/p/6030187.html][https_www.cnblogs.com_dongguacai_p_6030187.html]  
提交一个任务到线程池中，线程池的处理流程如下：

1、判断线程池里的核心线程是否都在执行任务，如果不是（核心线程空闲或者还有核心线程没有被创建）则创建一个新的工作线程来执行任务。如果核心线程都在执行任务，则进入下个流程。

2、线程池判断工作队列是否已满，如果工作队列没有满，则将新提交的任务存储在这个工作队列里。如果工作队列满了，则进入下个流程。

3、判断线程池里的线程是否都处于工作状态，如果没有，则创建一个新的工作线程来执行任务。如果已经满了，则交给饱和策略来处理这个任务。

![è¿éåå¾çæè¿°][2012121931.jpg]

RejectedExecutionHandler：饱和策略  
当队列和线程池都满了，说明线程池处于饱和状态，那么必须对新提交的任务采用一种特殊的策略来进行处理。这个策略默认配置是AbortPolicy，表示无法处理新的任务而抛出异常。JAVA提供了4中策略：

1、AbortPolicy：直接抛出异常

2、CallerRunsPolicy：只用调用所在的线程运行任务

3、DiscardOldestPolicy：丢弃队列里最近的一个任务，并执行当前任务。

4、DiscardPolicy：不处理，丢弃掉。

ExecutorService threadPool = Executors.newFixedThreadPool(3);// 创建可以容纳3个线程的线程池

ExecutorService threadPool = Executors.newCachedThreadPool();// 线程池的大小会根据执行的任务数动态分配

ExecutorService threadPool = Executors.newSingleThreadExecutor();// 创建单个线程的线程池，如果当前线程在执行任务时突然中断，则会创建一个新的线程替代它继续执行任务

ScheduledExecutorService threadPool = Executors.newScheduledThreadPool(3);// 效果类似于Timer定时器

[20150309140927553]: /images/20211210/e625da7fb9ff40359e698ae69ee187f6.png
[https_www.cnblogs.com_dongguacai_p_6030187.html]: https://www.cnblogs.com/dongguacai/p/6030187.html
[2012121931.jpg]: /images/20211210/3b3ef31c75e84e19a72b223fb076bf83.png