Java多线程笔记

于 2021-06-28 14:54:54 发布
阅读量219 收藏
点赞数 1
分类专栏： JavaSE 学习笔记
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_32591993/article/details/106693407
版权

多线程

Thread类

自定义线程类继承Thread类

重写 run() 方法，编写线程执行体

创建线程对象，调用 start() 方法启动线程

线程不一定立即执行，CPU安排调度

thread.start()和run()的区别

java中thread的start()和run()的区别：

1.start( )

start()方法来启动线程，真正实现了多线程运行，这时无需等待run方法体代码执行完毕而直接继续执行下面的代码：

通过调用Thread类的start()方法来启动一个线程，
这时此线程是处于就绪状态，
并没有运行。
然后通过此Thread类调用方法run()来完成其运行操作的，
这里方法run()称为线程体，
它包含了要执行的这个线程的内容，
Run方法运行结束，
此线程终止，
而CPU再运行其它线程，

2.run( )

run()方法当作普通方法的方式调用，程序还是要顺序执行，还是要等待run方法体执行完毕后才可继续执行下面的代码：

而如果直接用Run方法，
这只是调用一个方法而已，
程序中依然只有主线程–这一个线程，
其程序执行路径还是只有一条，
这样就没有达到写线程的目的。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-4L3RJFvK-1591867857823)(Java多线程笔记.assets/image-20200308180538338.png)]

package com.lj.demo01;

//创建线程方式一：继承Thread类，重写run()方法，调用start开启线程
//总结：注意，线程开启不一定要立即执行，由CPU调度执行
public class TestThread01 extends Thread{
    @Override
    public void run() {
        //run方法线程体
        for (int i = 0; i < 2000; i++) {
            System.out.println("我在写代码---" + i);
        }
    }

    public static void main(String[] args) {
        //main线程，主线程

        //创建一个线程对象
        TestThread01 testThread01 = new TestThread01();

        //调用start()方法开启线程
        testThread01.start();
        testThread01.run();//主线程会等待run()方法执行完毕，所以还是顺序执行

        for (int i = 0; i < 2000; i++) {
            System.out.println("我在听音乐---" + i);
        }
    }
}

小结

两种实现多线程的方法：

  • 继承Thread类
  • 实现Runnable接口

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-etbVSSUW-1591867857840)(Java多线程笔记.assets/image-20200310181554110.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-UL4Ia6CQ-1591867857845)(Java多线程笔记.assets/image-20200319144848539.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-tuKwUa80-1591867857852)(Java多线程笔记.assets/image-20200322232128615.png)]

Lamda表达式

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Nj8wliTc-1591867857856)(Java多线程笔记.assets/image-20200325164340353.png)]

package com.lj.lambda;

public class TestLambda01 {

    //3.静态内部类
    static class Like2 implements ILike{
        public void lambda(){
            System.out.println("I like lambda2");
        }
    }
    public static void main(String[] args) {
        ILike like = new Like();
        like.lambda();

        like = new Like2();
        like.lambda();

        //4.局部内部类
        class Like3 implements ILike{
            @Override
            public void lambda() {
                System.out.println("I like lambda3");
            }
        }

        like = new Like3();
        like.lambda();

        //5.匿名内部类，没有类的名称，必须借助接口和父类
        like = new ILike() {
            @Override
            public void lambda() {
                System.out.println("I like lambda4");
            }
        };
        like.lambda();

        //6.用lambda简化
        like = ()->{
            System.out.println("I like lambda5");
        };

        like.lambda();
    }
}

//1.定义一个函数式接口
interface ILike{
    void lambda();
}


//2.实现类
class Like implements ILike{
    @Override
    public void lambda() {
        System.out.println("I like lambda");
    }
}

package com.lj.lambda;

public class TestLambda02 {

    public static void main(String[] args) {
        ILove love = null;

        //1.lambda表示简化
        love = (int a,int b)-> {
            System.out.println("I love you-->"+a);
        };

        //简化1.参数类型
        love = (a,b)->{
            System.out.println("I love you-->"+a);
        };

        //简化2.简化括号
//        love = a->{
//            System.out.println("I love you-->"+a);
//        };

//        //简化3.去掉花括号
//        love = a-> System.out.println("I love you-->"+a);;

        love = (a,b)->{
            System.out.println("I love you-->"+a);
            System.out.println("I love you-->too");
        };

        //总结：多行不能简化括号
            //lambda表达式只能在只有一行的代码的情况下才能去掉花括号简化成为一行，如果有多行，那么就用代码块
            //前提是接口为函数式接口
            //多个参数也可以去掉参数类型，参数类型要去掉就都去掉，必须加上括号

        love.love(520,502);
    }
}


interface ILove{
    void love(int a,int b);
}

线程状态

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-0Vq2vUjP-1591867857857)(Java多线程笔记.assets/image-20200325203631536.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-MAEk1ozV-1591867857860)(Java多线程笔记.assets/image-20200325204714190.png)]

线程方法

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-yBfx0qBj-1591867857863)(Java多线程笔记.assets/image-20200325204957801.png)]

停止线程

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-fKi7vLgC-1591867857866)(Java多线程笔记.assets/image-20200325211330655.png)]

让线程自己停下来才是最安全的

package com.lj.state;

//测试stop
//1.建议线程正常停止--->利用次数，不建议死循环
//2.建议使用标志位--->设置一个标志位
//3.不要使用stop或者destroy等过时或者JDK不建议使用的方法
public class TestStop implements Runnable{
    //1.设置一个标识位
    private boolean flag = true;

    @Override
    public void run() {
        int i = 0;
        while(flag){
            System.out.println("run....Thread"+i++);
        }
    }

    //2.设置一个公开的方法停止线程，转换标志位
    public void stop(){
        this.flag = false;
    }

    public static void main(String[] args) {
        TestStop testStop = new TestStop();

        new Thread(testStop).start();

        for (int i = 0; i < 1000; i++) {
            System.out.println("main"+i);
            if(i == 900){
                //调用stop方法切换标志位，让线程停止
                testStop.stop();
                System.out.println("线程该停止了");
            }
        }
    }
}

线程休眠

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-KRmwn5n2-1591867857868)(Java多线程笔记.assets/image-20200325230849393.png)]

线程礼让

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-gLVO2lo1-1591867857870)(Java多线程笔记.assets/image-20200326174914981.png)]

线程强制执行

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-rvenpCoH-1591867857873)(Java多线程笔记.assets/image-20200326175851254.png)]

package com.lj.state;

//测试join方法
//想象成插队
public class TestJoin implements Runnable{
    @Override
    public void run() {
        for (int i = 0; i < 1000; i++) {
            System.out.println("线程vip来了"+i);
        }
    }

    public static void main(String[] args) throws InterruptedException {
        //启动我们的线程
        TestJoin testJoin = new TestJoin();
        Thread thread = new Thread(testJoin);
        thread.start();

        //主线程
        for (int i = 0; i < 500; i++) {
            if(i==200){
                thread.join();//插队
            }
            System.out.println("main"+i);
        }
    }
}

线程状态观测

Thread.State

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-OKhOBjWK-1591867857876)(Java多线程笔记.assets/image-20200507101040258.png)]

线程的五大状态

线程一旦进入死亡状态，就不能再次启动：线程只能运行一次

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-r6WwNaRF-1591867857877)(Java多线程笔记.assets/image-20200507102417629.png)]

package com.lj.state;

import sun.awt.windows.ThemeReader;

//观察测试线程的状态
public class TestState {
    public static void main(String[] args) throws InterruptedException {
        Thread thread = new Thread(()->{
            for (int i = 0; i < 1; i++) {
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            System.out.println("");
        });

        //观察状态
        Thread.State state = thread.getState();
        System.out.println(state);  //NEW

        //观察启动后
        thread.start();     //启动线程
        state = thread.getState();
        System.out.println(state);  //RUN

        while(state != Thread.State.TERMINATED){//只要线程不停止，就一直输出状态
            Thread.sleep(100);
            state = thread.getState();  //更新线程状态
            System.out.println(state);  //输出线程状态
        }
    }
}

线程的优先级

Java提供一个线程调度器来监控程序中启动后进入就绪状态的所有线程，线程调度器按照优先级决定应该调度哪个线程来执行

线程的优先级用数字来表示，范围从1~10

  • Thread.MIN_PRIORITY = 1；
  • Thread.MAX_PRIORITY = 10；
  • Thread.NORM_PRIORITY = 5；

使用以下方式改变或获取优先级

  • getPriority().setPriority(int xxx)

优先级高不一定先运行，优先级高的线程权重高，实际哪条线程先执行要看cpu的调度，优先级高先运行的几率大

可能会导致性能倒置的情况出现

package com.lj.state;

import java.lang.invoke.MutableCallSite;

public class TestPriority {
    public static void main(String[] args) {
        //主线程默认优先级
        System.out.println(Thread.currentThread().getName()+"-->"+Thread.currentThread().getPriority());

        MyPriority myPriority = new MyPriority();

        Thread t1 = new Thread(myPriority);
        Thread t2 = new Thread(myPriority);
        Thread t3 = new Thread(myPriority);
        Thread t4 = new Thread(myPriority);
        Thread t5 = new Thread(myPriority);
        Thread t6 = new Thread(myPriority);
        Thread t7 = new Thread(myPriority);
        Thread t8 = new Thread(myPriority);
        Thread t9 = new Thread(myPriority);
        Thread t10 = new Thread(myPriority);

        //先设置优先级，再启动
        t1.setPriority(Thread.MIN_PRIORITY);
        t1.start();

        t2.setPriority(2);
        t2.start();

        t3.setPriority(3);
        t3.start();

        t4.setPriority(4);
        t4.start();

        t5.setPriority(Thread.NORM_PRIORITY);
        t5.start();

        t6.setPriority(6);
        t6.start();

        t7.setPriority(7);
        t7.start();

        t8.setPriority(8);
        t8.start();

        t9.setPriority(9);
        t9.start();

        t10.setPriority(Thread.MAX_PRIORITY);
        t10.start();
    }
}

class MyPriority implements Runnable{

    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName()+"-->"+Thread.currentThread().getPriority());
    }
}

守护线程

守护线程(daemon)线程

  • 线程分为用户线程和守护线程
  • 虚拟机必须确保用户线程执行完毕
  • 虚拟机不用等待守护线程执行完毕
  • 如，后台记录操作日记、监控内存、垃圾回收、等待机制……
package com.lj.state;

//测试守护线程
//上帝守护你
public class TestDaemon {
    public static void main(String[] args) {
        God god = new God();
        You you = new You();

        Thread thread = new Thread(god);
        thread.setDaemon(true);     //默认是false表示是用户线程，正常的线程都是用户线程……

        thread.start();     //上帝 守护线程启动

        new Thread(you).start();       //你 用户线程启动
    }
}

//上帝
class God implements Runnable{

    @Override
    public void run() {
        while (true){
            System.out.println("上帝保佑着你");
        }
    }
}

//你
class You implements Runnable{

    @Override
    public void run() {
        for (int i = 0; i < 36500; i++) {
            System.out.println("你一生都开心的活着");
        }
        System.out.println("-----寿正终寝-----");
    }
}

线程同步

多个线程操作同一个资源

并发

同一个对象被多个线程同时操作

上万人同时抢一百张票、两个银行同时取钱

同一个资源，多个人都想使用：排队

处理多线程问题时，多个线程访问同一个对象，并且某些线程还想修改这个对象，这时候我们就需要线程同步，线程同步其实就是一个等待机制，多个需要同时访问此对象的线程进入这个对象的等待池形成队列，等待前面线程使用完毕，下一个线程再使用

队列 和 锁

例如很多人在厕所排队，如果厕所门没有锁，那么这个厕所就是不安全的

每个对象都有一把锁，队列+锁才能保证线程安全

  • 由于同一进程的多个线程共享同一块存储空间，在带来方便的的同时，也带来了访问冲突的问题，为了保证数据在方法中被访问时的正确性，在访问时加入锁机制synchronized，当一个线程获得对象的排他锁，独占资源，其他线程必须等待，使用后释放锁即可，存在以下问题：

    • 一个线程持有锁会导致其他所有需要此锁的线程被挂起(损失性能)
      • 例如上厕所的人在大号需要很长时间，其他所有的人都要排队等待
    • 在多线程竞争下，加锁，释放锁会导致比较多的上下文切换和调度延时，引起性能问题
    • 如果一个优先级高的线程等待一个优先级低的线程释放锁会导致优先级倒置，引起性能问题
      • 例如十分尿急的人必须等待厕所里便秘的人用完厕所才能进厕所

  • 我们可以通过private关键字来保证数据对象只能被方法访问，同理我们可以通过synchronized关键字，它包括两种方法：synchronized方法和synchronized块

    • 同步方法：

      public synchronized void method(int args[]){}

  • synchrinized方法控制对“对象“的访问，每个对象对应一把锁，每个synchronized方法都必须获得调用该方法的锁才能执行，否则线程会被阻塞，方法一旦执行，就独占该锁，直到该方法返回才释放锁，后面被阻塞的线程才能获得这个锁，继续执行

    • 缺陷：若将一个大的方法申明为synchronized将会影响效率

  • 方法里面需要修改的内容才需要锁

    • 锁的太多，浪费资源

同步块

  • synchronized(Obj){}
    • 要锁的对象一般来说就是被增删改查的对象
  • Obj称之为同步监视器
    • Obj可以是任何对象，但是推荐使用共享资源作为同步监视器
    • 同步方法中无需指定同步监视器，因为同步方法的同步监视器就是this，就是这个对象本身，或者是class[详见反射]
  • 同步监视器的执行过程
    1. 第一个线程访问，锁定同步监视器，执行其中代码
    2. 第二个线程访问，发现同步监视器被锁定，无法访问
    3. 第一个线程访问完毕，解锁同步监视器
    4. 第二个线程访问，发现同步监视器没有锁，然后锁定并访问

CopyOnWriteArrayList

package com.lj.syn;

import java.util.concurrent.CopyOnWriteArrayList;

//测试JUC安全类型的集合
public class TestJUC {
    public static void main(String[] args) {
        CopyOnWriteArrayList<String> list = new CopyOnWriteArrayList<String>();
        for (int i = 0; i < 10000; i++) {
            new Thread(()->{
                list.add(Thread.currentThread().getName());
            }).start();
        }
        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(list.size());
    }
}

死锁

多个线程各自占有一些共享资源，并且相互等待其他线程占有的资源才能运行，而导致两个或者多个线程都在等待对方释放资源，都停止执行的情形。某一个同步块同时拥有“两个以上对象的锁”时，就可能会发生“死锁”的问题

产生死锁的四个必要条件：
  1. 互斥条件：一个资源每次只能被一个进程使用
  2. 请求与保持条件：一个进程因请求资源而阻塞时，对已获得的资源保持不放
  3. 不剥夺条件：进程已获得的资源，在未使用完之前，不能强行剥夺
  4. 循环等待条件：若干进程之间形成一种头尾相接的循环等待资源关系

只要想办法破除其中的任意一个或多个条件就可以避免死锁发生

Lock(锁)

  • 从JDK5.0开始，Java提供了更强大的线程同步机制——通过显式定义同步锁对象来实现同步。同步锁使用Lock对象充当
  • java.util.concurrent.locks.Lock接口是控制多个线程对共享资源进行访问的工具。锁提供了对共享资源的独占访问，每次只能有一个线程对Lock对象加锁，线程开始访问共享资源之前应先获得Lock对象
  • ReentranLock(可重入锁)类实现了Lock，它拥有与synchronized相同的并发性和内存语义，在实现线程安全的控制中，比较常用的是ReentrantLock，可以显式加锁、释放锁
class A{
    private final ReentranLock lock = new ReenTrantLock();
    public void m(){
        lock.lock();
        try{
            	//保证线程安全的代码
        }finally{
            lock.unlock();
            //如果同步代码有异常，要将unlock()写入finally语句块
        }
    }
}

synchronized 与 Lock 的对比

  • Lock是显式锁(手动开启和关闭锁，别忘记关闭锁) synchronized是隐式锁，出了作用域自动释放
  • Lock只有代码块锁，synchronized有代码块锁和方法锁
  • 使用Lock锁，JVM将花费较少的时间来调度线程，性能更好。并且具有更好地扩展性(提供更多的子类)
  • 优先使用顺序
    • Lock > 同步代码块（已经进入了方法体，分配了相应资源）> 同步方法（在方法体之外）

线程协作-线程通信

  • 应用场景：生产者和消费者问题
    • 假设仓库中只能存放一件产品,生产者将生产出来的产品放入仓库,消费者将仓库中产品取走消费
    • 如果仓库中没有产品，则生产者将产品放入仓库,否则停止生产并等待,直到仓库中的产品被消费者取走为止
    • 如果仓库中放有产品,则消费者可以将产品取走消费,否则停止消费并等待，直到仓库中再次放入产品为止

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-3USPZGnK-1591867857881)(Java多线程笔记.assets/image-20200507205614366.png)]

生产者和消费者问题分析

这是一个线程同步问题，生产者和消费者共享同一个资源，并且生产者和消费者之间相互依赖，互为条件

  • 对于生产者，没有生产产品之前,要通知消费者等待。而生产了产品之后，又需要马上通知消费者消费

  • 对于消费者，在消费之后，要通知生产者已经结束消费，需要生产新的产品以供消费

  • 在生产者消费者问题中，仅有synchronized是不够的

    • synchronized 可阻止并发更新同一个共享资源，实现了同步
    • synchronized 不能用来实现不同线程之间的消息传递（通信）

  • Java提供了几个方法解决线程之间的通信问题

    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-H8XWk4r9-1591867857882)(Java多线程笔记.assets/image-20200507210310240.png)]

生产者和消费者问题的解决方法

管程法

并发协作模型“生产者/消费者模式”–>管程法

  • 生产者：负责生产数据的模块（可能是方法，对象，线程，进程）
  • 消费者：负责处理数据的模块（可能是方法，对象，线程，进程）
  • 缓冲区：消费者不能直接使用生产者的数据，他们之间有个“缓冲区“

生产者将生产好的数据放入缓冲区，消费者从缓冲区拿出数据

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-AhmvOpLd-1591867857885)(Java多线程笔记.assets/image-20200507205614366.png)]

package com.lj.gaoji;

//测试：生产者消费者模型-->利用缓冲区解决：管程法

//生产者，消费者，产品，缓冲区
public class TestPC {
    public static void main(String[] args) {
        SynContainer container = new SynContainer();

        new Productor(container).start();
        new Consumer(container).start();
    }
}

//生产者
class Productor extends Thread{
    SynContainer container;

    public Productor(SynContainer container){
        this.container = container;
    }

    //生产
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            container.push(new Chicken(i));
            System.out.println("生产了"+i+"只鸡");
        }
    }
}

//消费者
class Consumer extends Thread{
    SynContainer container;

    public Consumer(SynContainer container){
        this.container = container;
    }

    //消费
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.println("消费了"+container.pop().id+"只鸡");
        }
    }
}

//产品
class Chicken{
    int id; //产品编号

    public Chicken(int id) {
        this.id = id;
    }
}

//缓冲区
class SynContainer{
    //需要一个容器大小
    Chicken[] chickens = new Chicken[10];
    //容器计数器
    int count = 0;

    //生产者放入产品
    public synchronized void push(Chicken chicken){
        //如果容器满了，就需要等待消费者消费
        if(count == chickens.length){
            //通知消费者消费，生产等待
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        //如果没有满，我们就需要丢入产品
        chickens[count] = chicken;
        count++;

        //可以通知消费者消费了
        this.notifyAll();
    }

    //消费者消费产品
    public synchronized Chicken pop(){
        //判断能否消费
        if(count==0){
            //等待生产者生产，消费者等待
        }

        //如果可以消费
        count--;
        Chicken chicken = chickens[count];

        //吃完了，通知生产者生产
        return chicken;
    }
}
信号灯法

并发协作模型“生产者/消费者模式" ->信号灯法

package com.lj.gaoji;

import com.sun.xml.internal.ws.runtime.config.TubelineFeatureReader;
import sun.font.TrueTypeFont;

//测试生产者消费者问题2：信号灯法，标志位解决
public class TestPC2 {
    public static void main(String[] args) {
        TV tv = new TV();
        new Player(tv).start();
        new Watcher(tv).start();
    }
}

//生产者-->电视台
class Player extends Thread{
    TV tv;
    public Player(TV tv){
        this.tv = tv;
    }

    @Override
    public void run() {
        for (int i = 0; i < 20; i++) {
            if(i%2==0){
                this.tv.play("快乐大本营");
            }else{
                this.tv.play("广告");
            }
        }
    }
}

//消费者-->观众
class Watcher extends Thread{
    TV tv;
    public Watcher(TV tv){
        this.tv = tv;
    }

    @Override
    public void run() {
        for (int i = 0; i < 20; i++) {
            tv.watch();
        }
    }
}

//产品-->节目
class TV{
    //电视台安排节目，观众等待
    //观众观看，电视台等待
    String voice;   //电视台安排的节目
    boolean flag = true;

    //播放节目
    public synchronized void play(String voice){
        if(!flag){
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        System.out.println("电视台播放了："+voice);
        //通知观众观看
        this.notifyAll();   //通知唤醒
        this.flag = !this.flag;
        this.voice = voice;
    }

    //观看
    public synchronized void watch(){
        if(flag){
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        System.out.println("观众观看了："+voice);
        //通知电视台安排节目
        this.flag = !this.flag;
        this.notifyAll();
    }
}

用一个flag标志，让两个线程轮流工作，类似于十字路口的红绿灯让车辆和行人轮流经过

线程池

  • 背景：用于经常创建和销毁、使用量特别大的资源，比如并发情况下的线程，对性能影响很大
  • 思路：提前创建好多个线程，放入线程池中，使用时直接获取，使用完放回池中。
    可以避免频繁创建销毁、实现重复利用。类似于共享单车
  • 好处：
    • 提高响应速度（减少了创建新线程的时间）
    • 降低资源消耗（重复利用线程池中线程，不需要每次都创建）
    • 便于线程管理（……）
      • corePoolSize：核心池的大小（可以放多少个线程）
      • maximumPoolSize：最大线程数（可以跑多少个线程）
      • keepAliveTime：线程没有任务时最多保持多长时间后会终止（线程什么时候销毁）

JDK 5.0起提供了线程池相关API ：ExecutorService 和 Executors

  • ExecutorService：真正的线程池接口。常见子类ThreadPoolExecutor
    • void execute(Runnable command) ：执行任务/命令，没有返回值，一般用来执行Runnable
    • Future submit(Callable task)：执行任务，有返回值，一般用来执行Callable
    • void shutdown()：关闭连接池
  • Executors ：工具类、线程池的工厂类，用于创建并返回不同类型的线程池

总结

package com.lj.gaoji;

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

//回顾总结线程的创建
public class ThreadNew {
    public static void main(String[] args) {
        new MyThread1().start();
        new Thread(new MyThread2()).start();

        FutureTask<Integer> futureTask = new FutureTask<Integer>(new MyThread3());
        new Thread(futureTask).start();

        try {
            Integer integer = futureTask.get();
            System.out.println(integer);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
    }
}

//1.继承Thread类
class MyThread1 extends Thread{
    @Override
    public void run() {
        System.out.println("MyThread1");
    }
}

//2.实现Runnable接口
class MyThread2 implements Runnable{
    @Override
    public void run() {
        System.out.println("MyThread2");
    }
}

//3.实现Callable接口
class MyThread3 implements Callable<Integer>{
    @Override
    public Integer call() throws Exception {
        System.out.println("MyThread3");
        return 100;
    }
}
请刷新后重试
关注
专栏目录
JVM invokedynamic调用指令
feather(猎羽)
09-16 1627
转载请注明链接: JVM invokedynamic调用指令 版本号:2018/09/15-1(0:00) JVM invokedynamic调用指令 基础-方法句柄(32) 赛马问题 方法句柄 创建 操作 方法句柄的实现 方法句柄性能 invokedynamic调用指令(28) 调用点 invokedynamic使用实例 Java8 Lambda表达式 Lambda...
手把手搭建一个完整的javaweb项目(适合新手)
热门推荐
yurong33333的博客
03-17 10万+
致谢：在此感谢落尘曦的参考博文，附上原文地址 说明：只是实现了简单的操作，但是逻辑并不严谨，仅适合新手，望注意。 开发环境与工具 IntelliJ IDEA 2018.3.3（Ultimate Edition） Mysql Workbench8.0 jdk11 Tomcat 功能说明 用户登录 新用户注册 用户列表展示 用户信息删除 用户信息更新 操作步骤 在mysql建立一个新表Stu...
搭建一个完整的javaweb项目
yi_HelloC的博客
02-19 450
开发环境与工具 1.IntelliJ IDEA 2020（Ultimate Edition）（Mac版本） 2.Mysql 8.0.8 3.jdk8 4.Tomcat for mac ( 安装教程 ) 功能: 用户登录 新用户注册 用户列表展示 用户信息删除 用户信息更新 操作步骤 1.在mysql建立一个新表Student，里面有name,password,id（为了简化操作，所以只有三列并且都是String类型） create table if not exists Student (name varc
JDK7动态方法调用
云原生之家
12-20 4597
在JDK7中，Java提供了对动态语言特性的支持，实现了JSR 292 《Supporting Dynamically Typed Languages on the Java Platform》规范，这是Java语言发展的一重大进步，而提供对动态语言特性支持也是Java发展的一大趋势与方向。那么动态性表现在哪里呢？其一在Java API层面，新增了java.lang.invoke包，主要包含了Ca
java多线程笔记
12-10
Java线程的知识点总结。doc
java多线程笔记分享
12-22
java多线程笔记分享
_Command_line_settings_desktop_wallpaper_tool,_Su_command-wallpa
09-17
_Command_line_settings_desktop_wallpaper_tool,_Su_command-wallpaper
IMG_20240917_151703.jpg
09-17
IMG_20240917_151703.jpg
吉他谱_Pneuma - Tool.pdf
09-17
初级入门吉他谱 guitar tab
Java项目-基于SSM+Jsp的计算机网络课程试卷生成器系统的设计与实现（源码+数据库脚本+部署视频+代码讲解视频+全套软件）
09-17
【基于SSM+Jsp的计算机网络课程试卷生成器系统的设计与实现】高分通过项目，已获导师指导。 本项目是一套基于SSM+Jsp的计算机网络课程试卷生成器系统，主要针对计算机相关专业的正在做毕设的学生和需要项目实战练习的Java学习者。也可作为课程设计、期末大作业 包含：项目源码、数据库脚本、开发说明文档、部署视频、代码讲解视频、全套软件等，该项目可以直接作为毕设使用。 项目都经过严格调试，确保可以运行！
基于JavaSE实现磁盘小助手系统（源码&实验报告）
09-17
实验内容： 根据所学的File类，结合循环，分支判断等知识，采用Idea开发工具开发一个磁盘文件小助手的案例，具体功能要求如下： 1.作品要立意新颖、主题鲜明，鼓励原创，避免雷同，有独特的创造力和较强的吸引力。 2.内容健康、代码规范，整个系统的风格要统一，结构要合理。 3.作品要求是一个可以运行的控制台小程序 4.作品中要充分利用File,String常用方法，判断，循环等技术来实现自己的作品 5.内容要求： 1)使用Idea创建基本项目结构，实现磁盘文件小助手软件； 2)实现获取本地磁盘所有磁盘目录的方法； 3)要有一个控制台的界面，界面信息循环展示，输出0退出系统 1.实现文件路径回退一步 2.进入到目录内部 3.创建一个文件功能 4.实现删除文件功能 5.展示该目录下的所有文件或文件夹功能 6.展示本电脑下的所有的java文件 7.创建文件夹功能 8.移除文件夹下所有文件及目录的功能 9.显示本机电脑所有磁盘的信息 0.退出系统功能 4)要求用户输入相应的数字实现相应的操作功能； 5)要求输入0的时候，实现退出系统功能； 6)要求操作的文件路径需要从键盘动态获取； 7)需要
吉他谱_Star Spangled Banner - Metallica.pdf
09-17
初级入门吉他谱 guitar tab
c1900-universalk9-mz.SPA.151-3.T1.bin
最新发布
09-17
c1900-universalk9-mz.SPA.151-3.T1.bin
Python 3 介绍（十八）--面向对象编程.docx
09-17
Python 3 介绍（十八）--面向对象编程
jdk9 免安装包，配置环境变量即可
09-17
jdk9 免安装包，配置环境变量即可
Linux命令cp实现代码_cp_code.zip
09-17
Linux命令cp实现代码_cp_code
VNX读写缓存设置.docx
09-17
EMC存储最佳配置
Java项目-基于SSM+Jsp的校园驿站管理系统的设计与实现（源码+数据库脚本+部署视频+代码讲解视频+全套软件）
09-17
【基于SSM+Jsp的校园驿站管理系统的设计与实现】高分通过项目，已获导师指导。 本项目是一套基于SSM+Jsp的校园驿站管理系统，主要针对计算机相关专业的正在做毕设的学生和需要项目实战练习的Java学习者。也可作为课程设计、期末大作业 包含：项目源码、数据库脚本、开发说明文档、部署视频、代码讲解视频、全套软件等，该项目可以直接作为毕设使用。 项目都经过严格调试，确保可以运行！
狂神说java多线程笔记
10-11
Java多线程是Java语言中的一个重要特性，可以让程序同时执行多个任务，提高程序的效率和性能。狂神在他的Java多线程笔记中，详细介绍了Java多线程的相关知识，包括线程的创建、启动、停止、等待、唤醒等操作，以及线程安全、锁、同步等概念和技术。 在Java多线程中，线程的创建有两种方式：继承Thread类和实现Runnable接口。其中，实现Runnable接口更为常用，因为它可以避免单继承的限制，并且更符合面向对象的设计原则。 线程的启动使用start()方法，而不是run()方法。start()方法会启动一个新的线程，并在新线程中执行run()方法中的代码。 线程的停止可以使用stop()方法，但这个方法已经被废弃了，因为它可能会导致线程不安全。更好的方式是使用interrupt()方法来中断线程，并在run()方法中检查中断标志位来安全地停止线程。 线程的等待和唤醒可以使用wait()、notify()和notifyAll()方法来实现。wait()方法会使当前线程进入等待状态，并释放锁；notify()和notifyAll()方法会唤醒等待在同一个对象上的其他线程。 线程安全是指多个线程同时访问共享资源时，不会出现数据不一致或者程序崩溃等问题。为了保证线程安全，可以使用锁和同步机制来控制对共享资源的访问。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值