java 多线程

sutaking 发布于2019-08-15 14:49 / 2356人阅读

摘要：的多线程有好几种，可以继承，也可以实现接口，还可以实现接口继承，自己实现方法，就可以定一个线程类，调用就可以在一个新的线程里面调用方法，如果需要等待线程结束，可以调用方法和差不多，只不过不直接继承，而是实现接口只有一个方法，使用上面用这个去

java 的多线程有好几种，可以继承 Thread，也可以实现 Runnable 接口，还可以实现 Callable 接口

Thread

</>复制代码 
class MyThread extends Thread {
    private String name;
    public MyThread(String name) {
        this.name = name;
    }
    @Override
    public void run() {
        for (int i = 0; i < 5; i++) {
            try {
                Thread.sleep(100L);
            } catch (Exception e) {
                e.printStackTrace();
            }
            System.out.printf("%s is running %d
", name, i);
        }
    }
}
{
    Thread t1 = new MyThread("t1");
    Thread t2 = new MyThread("t2");
    t1.start();
    t2.start();
    try {
        t1.join();
        t2.join();
    } catch (Exception e) {
        e.printStackTrace();
    }
}

继承 Thread，自己实现 run 方法，就可以定一个线程类，调用 start 就可以在一个新的线程里面调用 run 方法，如果需要等待线程结束，可以调用 join 方法

Runnable

</>复制代码 
class MyRunnable implements Runnable {
    private String name;
    public MyRunnable(String name) {
        this.name = name;
    }
    @Override
    public void run() {
        for (int i = 0; i < 5; i++) {
            try {
                Thread.sleep(100L);
            } catch (Exception e) {
                e.printStackTrace();
            }
            System.out.printf("%s is running %d
", name, i);
        }
    }
}
{
    Thread r1 = new Thread(new MyRunnable("r1"));
    Thread r2 = new Thread(new MyRunnable("r2"));
    r1.start();
    r2.start();
    try {
        r1.join();
        r2.join();
    } catch (Exception e) {
        e.printStackTrace();
    }
}

和 Thread 差不多，只不过不直接继承 Thread，而是实现 Runnable 接口（Runable 只有一个 run 方法），使用上面用这个 Runnable 去构造一个 Thread，这种方式相对直接继承 Thread 的方式要更加灵活，因为 java 是单继承，如果继承了 Thread 就不能再继承别的类

事实上，建议永远不要直接继承 Thread 类，因为从语义上来讲，Thread 也应该也只是方法运行的方式，你的类应该是可以在这种方式下运行，而不是一种 Thread 对象，从这个角度讲，Runnable 提供了更好的语义，用一个 Thread 对象去运行一个 Runable

Callable

</>复制代码 
class MyCallable implements Callable {
    private Random random;
    public MyCallable() {
        this.random = new Random();
    }
    @Override
    public Integer call() throws Exception {
        Thread.sleep(100L);
        return this.random.nextInt();
    }
}
{
    FutureTask future1 = new FutureTask<>(new MyCallable());
    FutureTask future2 = new FutureTask<>(new MyCallable());
    new Thread(future1).start();
    new Thread(future2).start();
    try {
        System.out.println(future1.get(50, TimeUnit.MILLISECONDS));
    } catch (TimeoutException e) {
        System.out.println("future1 timeout");
    } catch (Exception e) {
        e.printStackTrace();
    }
    try {
        System.out.println(future2.get());
    } catch (Exception e) {
        e.printStackTrace();
    }
}

Callable 接口也只有一个方法 call，和 Runnable 不同的是 Callable 允许有返回值，而这个返回值可以通过 FutureTask.get 获取，还可以设置任务运行的超时时间，超时后会抛出一个异常

ThreadPool

</>复制代码 
class MyCallable implements Callable {
    private Random random;
    public MyCallable() {
        this.random = new Random();
    }
    @Override
    public Integer call() throws Exception {
        Thread.sleep(100L);
        return this.random.nextInt();
    }
}
{
    ExecutorService es = Executors.newFixedThreadPool(5);
    Future future1 = es.submit(new MyCallable());
    Future future2 = es.submit(new MyCallable());
    try {
        System.out.println(future1.get(50, TimeUnit.MILLISECONDS));
    } catch (TimeoutException e) {
        System.out.println("future1 timeout");
    } catch (Exception e) {
        e.printStackTrace();
    }
    try {
        System.out.println(future2.get());
    } catch (Exception e) {
        e.printStackTrace();
    }
    es.shutdown();
}

java 里面线程的创建和销毁成本比较大，所以一般会需要放到线程池里面跑，java 的基础设施就是好，这些在标准库里面都有实现，使用上面也很简单，直接 new 出一个线程池就好了，然后就可以往里面 submit Callable 对象，线程池也有很多种，上面用到的 newFixedThreadPool 是固定线程数的线程池，下面用到的 newCachedThreadPool 在线程不够用的时候会创建新线程，同时也会不断复用之前创建的线程

</>复制代码 
{
    ExecutorService es = Executors.newCachedThreadPool();
    CompletionService cs = new ExecutorCompletionService<>(es);
    cs.submit(new MyCallable());
    cs.submit(new MyCallable());
    cs.submit(new MyCallable());
    cs.submit(new MyCallable());
    try {
        System.out.println(cs.take().get());
        System.out.println(cs.take().get());
        System.out.println(cs.take().get());
        System.out.println(cs.take().get());
    } catch (Exception e) {
        e.printStackTrace();
    }
    es.shutdown();
}

典型的生成者消费者模型里面，我们需要把生产的结果放到一个队列里面，而消费者从这个队列里面不断地去消费，ExecutorCompletionService 就相当于这个队列，MyCallable 的结果会写入到缓存里面，使用 cs.take().get() 从里面取出结果

总结

线程的创建，销毁，切换在 java 里面都是耗性能的操作，如果有需求要大量地创建线程，尽量使用线程池去复用线程

参考链接

测试代码链接：https://github.com/hatlonely/...

“implements Runnable” vs. “extends Thread” ：https://stackoverflow.com/que...

</>复制代码 
转载请注明出处 
本文链接：http://hatlonely.com/2018/03/...

GPU云服务器云服务器 java多线程多线程调试 java java多线程分发 java多线程并发

文章版权归作者所有，未经允许请勿转载,若此文章存在违规行为，您可以联系管理员删除。

转载请注明本文地址：https://www.ucloud.cn/yun/68835.html

Java多线程学习（一）Java多线程入门

摘要：最近听很多面试的小伙伴说，网上往往是一篇一篇的多线程的文章，除了书籍没有什么学习多线程的一系列文章。将此线程标记为线程或用户线程。最近听很多面试的小伙伴说，网上往往是一篇一篇的Java多线程的文章，除了书籍没有什么学习多线程的一系列文章。但是仅仅凭借一两篇文章很难对多线程有系统的学习，而且面试的时候多线程这方面的知识往往也是考察的重点，所以考虑之下决定写一系列关于Java多线程的文章...

Donne 2019-08-15 15:15 评论0 收藏0
Java多线程专题一：并发所面临的问题

摘要：但是并不是什么多线程就可以随便用，有的时候多线程反而会造成系统的负担，而且多线程还会造成其他的数据问题，下面就来介绍一下多线程面临的问题。下面这张图是多线程运行时候的情况，我们发现上下文切换的次数暴增。并发的概念：在Java中是支持多线程的，多线程在有的时候可以大提高程序的速度，比如你的程序中有两个完全不同的功能操作，你可以让两个不同的线程去各自执行这两个操作，互不影响，不需要执行...

madthumb 2019-08-15 15:40 评论0 收藏0
Java多线程可以分组，还能这样玩！

摘要：如图所示，带有的所有线程构造方法都可以定义线程组的。线程组还能统一设置组内所有线程的最高优先级，线程单独设置的优先级不会高于线程组设置的最大优先级。前面的文章，栈长和大家分享过多线程创建的3种方式《实现 Java 多线程的 3 种方式》。但如果线程很多的情况下，你知道如何对它们进行分组吗？和 Dubbo 的服务分组一样，Java 可以对相同性质的线程进行分组。来看下线程类 Th...

biaoxiaoduan 2019-08-16 13:38 评论0 收藏0
JAVA 多线程和并发基础

摘要：线程可以被称为轻量级进程。一个守护线程是在后台执行并且不会阻止终止的线程。其他的线程状态还有，和。上下文切换是多任务操作系统和多线程环境的基本特征。在的线程中并没有可供任何对象使用的锁和同步器。原文：Java Multi-Threading and Concurrency Interview Questions with Answers 翻译：并发编程网 - 郑旭东校对：方腾飞多...

vboy1010 2019-08-14 11:44 评论0 收藏0
Java多线程学习（七）并发编程中一些问题

摘要：相比与其他操作系统包括其他类系统有很多的优点，其中有一项就是，其上下文切换和模式切换的时间消耗非常少。因为多线程竞争锁时会引起上下文切换。减少线程的使用。很多编程语言中都有协程。所以如何避免死锁的产生，在我们使用并发编程时至关重要。系列文章传送门: Java多线程学习（一）Java多线程入门 Java多线程学习（二）synchronized关键字（1） java多线程学习（二）syn...

dingding199389 2019-08-15 15:30 评论0 收藏0
学习Java多线程的一些总结

摘要：多线程环境下的一些问题安全性问题在没有正确同步的情况下，多线程环境下程序可能得出错误的结果。一些相关概念竞争条件多线程的环境下，程序执行的结果取决于线程交替执行的方式。而线程的交替操作顺序是不可预测的，如此程序执行的结果也是不可预测的。入口 Java多线程的应用复杂性之如jvm有限的几个内存方面的操作和规范，就像无数纷繁复杂的应用逻辑建立在有限的指令集上。如何写出线程安全的程序，有...

coolpail 2019-08-15 15:58 评论0 收藏0