Java线程和线程池

最新推荐文章于 2021-05-17 22:36:53 发布

an-ping

最新推荐文章于 2021-05-17 22:36:53 发布

阅读量196

点赞数 1

分类专栏： java

本文链接：https://blog.youkuaiyun.com/qq_40693828/article/details/95644233

版权

java 专栏收录该内容

34 篇文章

订阅专栏

创建线程的方式：继承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();
        }
    }
}
//输出结果
线程执行
线程返回结果

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

对于线程中常用的方法有：
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.youkuaiyun.com/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
提交一个任务到线程池中，线程池的处理流程如下：

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

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

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

è¿éåå¾çæè¿°