大神之路：Java再撸一遍：Java多特么的线程

最新推荐文章于 2020-02-19 16:11:49 发布
最新推荐文章于 2020-02-19 16:11:49 发布
阅读量669 收藏 1
点赞数
分类专栏： JAVASE 文章标签： javase 多线程 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/probuing/article/details/53215320
版权

java多线程

线程的概述

容易混淆的概念——线程和进程
  • 进程

所有运行中的任务通常对应一个进程(Process),通常当一个程序进入内存运行时，就会变成一个进程。进程时处于运行过程中的程序，具有一定的独立功能。

  • 进程的特性：
    1、独立性：进程时系统中独立存在的实体，拥有自己的独立资源，每一个进程都拥有自己的私有地址空间。一个用户进程不可以直接访问其他进程的地址空间
    2、动态性：程序时一个静态的指令集合，进程时一个正在系统中活动的指令集合。
    3、多个进程可以再处理器上并发执行，多个进程之间不会互相影响
* expand
    > 并发性和并行性：
        并行是指再同一时刻有多条指令在处理器上同时执行，并发指再同一时刻只能有一条指令执行，但多个进程指令被快速轮换执行
  • 线程

同一个进程可以同时并发处理多个任务。线程也被称为轻量级的进程。线程在操作系统中是独立的、并发的执行流。对于绝大多数应用来说，一个应用程序通常仅要求有一个主线程。可以有多个线程的执行流。

  • 线程的特性

    1、线程可以与其他线程共享父进程中的共享变量及部分环境。
    2、线程时独立运行的，线程的执行时抢占式的

  • 线程的优势

    • 进程之间不能共享内存，线程之间可以共享内存
    • 系统创建线程所需要重新分配的系统资源要小的多
    • java语言内置流多线程的支持不是作为底层操作系统的调度方式，简化流编程
线程的创建和启动
  • 在java中Thread代表线程，所有的线程对象都必须时Thread类或其子类的实例。
继承Thread类创线程类
  • 定义类继承Thread类
  • 重写Thread类的run方法，该run()方法为线程需要完成的任务，run()方法为线程的执行体
  • 创建Thread的实例，即创建线程对象
  • 调用线程对象的start()来创建并启动线程
Thread API
  • Thread.getCurrentThread():
    Thread类的静态方法，该方法返回当前正在执行的线程对象
  • getName()
    该方法是Thread类的实例方法。该方法返回调用该方法的线程的名字
problem
  • 通过继承Thread类对象来创建线程类的时候，多个线程之间无法共享线程类的实例变量
/**
 * Created by D9ing on 2016/11/14.
 * 通过继承Thread来创建线程
 */
public class ExtendsThreadWay {


    public static void main(String[] args) {
        for (int i = 0; i < 200; i++) {
            System.out.println("当前线程为" + Thread.currentThread().getName());
            if (i == 100) {
                ThreadWay threadWay1 = new ThreadWay();
                ThreadWay threadWay2 = new ThreadWay();
                threadWay1.start();
                threadWay2.start();
            }
        }

    }

}

/**
 * 线程实体类
 */
class ThreadWay extends Thread {
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.println(getName() + "线程" + i);
        }

    }
}
实现Runnable接口创建线程类
  • 创建Runnable的实现类
  • 重写Runnable的run(),该run()方法是线程的执行体
  • 创建Runaable实现类的实例，并以此实例作为Thread的target来创建Thread对象
  • 调用线程对象的start()方法来启动线程
/**
 * Created by D9ing on 2016/11/14.
 * 实现Runnable创建线程
 */
public class ImpRunnableWay {

    public static void main(String[] args) {

        for (int i = 0; i < 20; i++) {
            System.out.println(Thread.currentThread().getName() + "isRun()");
            if (i == 18) {
                new Thread(new RunnableThread(), "name1").start();
                new Thread(new RunnableThread(), "name2").start();
            }
        }

    }
}

/**
 * 线程的实现类
 */
class RunnableThread implements Runnable {

    //定义实例变量
    private int i;

    @Override
    public void run() {
        for (; i < 100; i++) {
            System.out.println(Thread.currentThread().getName() + "isRun()...");
        }

    }
}
使用Callable和Future创建线程

从jdk 1.5开始 java提供了Callable接口，该接口提供了一个call()方法可以作为线程的执行体

  • call()方法比run()方法强大，call()可以有返回值
  • call()方法可以抛出异常
Future
  • java5提供了Future接口来代表Callable接口中的call()方法的返回值，并为Future接口提供了一个FutureTask实现类。该类实现了Future接口，并实现了Runnable接口
  • Future接口中定义的方法
  • boolean cancel(boolean b) 试图取消该Future里关联的Callable任务
  • V get() 返回Callable任务里call()方法的返回值，调用该方法将导致程序阻塞。必须等到子线程执行完毕后程序才会得到返回值
  • boolean isCancelled() 如果在Callable任务正常返回前被取消，则返回true
  • boolean isDone() 如果Callable任务已完成，泽返回true

Callable接口有泛型的限制，Callable接口中的泛型形参类型与call()方法返回值类型相同

步骤
  • 创建Callable接口的实现类
  • 实现Callable的call()方法，并将该方法作为线程执行体。且该call()方法有返回值
  • 使用FutureTask类来包装Callable对象，并且该FutureTask对象封装了该Callable对象的call方法
  • 使用FutureTask类来包装Callable对象，该FutureTask对象封装了该Callable对象的call()方法
  • 使用FutureTask作为Thread对象的target创建并启动新线程
  • 调用Futuretask对象的get()方法来获得子线程执行结束后的返回值
/**
 * Created by D9ing on 2016/11/14.
 * 使用Callable Future 接口创建线程
 */
public class CallableWay {
    public static void main(String[] args) {

        int i = 0;
        FutureTask<String> futureTask = new FutureTask<>(new CallableThread());
        for (; i < 100; i++) {
            System.out.println(Thread.currentThread().getName() + "---循环比变量i的值" + i);
            if (i == 50) {

                //创建FutureTask对象
                new Thread(futureTask, "有返回值的线程").start();


            }
        }
        // TODO: 获取线程的返回值
        try {
            System.out.println(futureTask.get() + "返回值");
        } catch (Exception e) {
            e.printStackTrace();
        }

    }

}

/**
 * 泛型为Callable call方法的返回值
 */
class CallableThread implements Callable<String> {

    private int i = 0;

    @Override
    public String call() throws Exception {
        for (; i < 100; i++) {
            System.out.println(Thread.currentThread().getName() + "---循环变量的值" + i);

        }
        return String.valueOf(i);
    }
}
创建三种线程的方式对比
方式 优点 缺点
继承Thread 编程简单，获取当前对象方便 已经继承了Thread类不能再继承其它父类
实现Runnaleb、Callable 可以实现多个接口，可以继承别的父类，可以共享实例的变量, 实现Callable接口的线程可以具有返回值 编程复杂，获得当前线程对象需要使用Thread.currentThread()
线程的生命周期

当一个线程被创建后，它既不是一启动就处于运行状态，也不是一直处于执行状态。在线程的生命周期中，线程要经过 新建(new)--->就绪(Runnable)--->运行(Running)--->阻塞(Blocked)--->死亡(dead) 一些状态。当线程启动后，线程并不能一直占有着cpu资源。cpu会在多条线程之间切换。线程也就会在多次执行、阻塞之间切换

新建和就绪状态
  • 线程使用new关键字创建后，就会进入新建状态。等待jvm为其分配内存。初始化成员变量值
  • 当线程调用start()方法后，线程进入就绪状态，虚拟机JVM会为该线程创建方法调用栈和程序计数器。该状态中的线程并没有运行，只是表示该线程可以运行了，是否开始运行取决于jvm中线程调度器的调度
运行和阻塞状态

  • 处于就绪状态的线程获得了CPU资源，开始执行run()方法的线程执行体，该线程处于运行状态，在cpu调度中，当线程数大于处理器数时，依然会存在多个线程在同一个cpu上轮换的现象

  • 一个线程开始运行后，就不可能一直处于运行状态，线程在运行过程中需要被中断，目的时让其他的线程获得执行的机会。线程的调度取决于底层的策略。

    • 对于抢占式策略的系统来说，系统会给每一个可执行的线程一个时间段来处理任务。当时间段用完后，系统就会剥夺该线程所占用的资源。让其它线程获得执行的机会。
    • 对于协作式调度策略的cpu中只有当一个线程调用了它的sleep()或yield()方法后才会放弃所占用的资源

  • 当正在执行的线程被阻塞之后，其他线程获得执行的机会，被阻塞的线程会在合适的时候重新进入就绪状态。被阻塞的线程阻塞状态解除后，需要重新等待线程调度器再次调度它。

  • 线程从阻塞状态只能进入就绪状态，无法直接进入运行状态。而就绪和运行状态的转换不受程序的控制

线程进入阻塞状态的情况
  • 线程调用sleep()方法主动放弃所占用的处理器资源
  • 线程调用了一个阻塞式IO方法，在方法返回之前，线程被阻塞
  • 线程试图获得一个同步监视器。但该监视器被其他线程所有
  • 线程等待某个通知(notity)
  • 调用线程的suspend()方法将线程挂起
线程解除阻塞状态重新进入就绪状态
  • 调用的sleep()方法过了指定时间
  • 线程调用的sleep()方法已经返回
  • 线程获得同步监视器
  • 线程获得某个通知
  • 线程被调用resume()状态

线程的状态转换图

新建
就绪
运行
阻塞
死亡
线程的死亡

线程以如下的方式结束，结束后就会死亡

  • run()或call()方法执行完成，线程正常结束
  • 线程抛出一个未捕获的Exception或Error
  • 直接调用线程的stop()方法
  • 为了测试某个线程是否已经死亡，可以调用线程对象的isAlive()方法。当线程处于就绪、运行、阻塞状态时会返回true,处于新建、死亡状态时会返回false
tips
  • 不要对一个已经死亡的线程调用start()方法。将引发IllegalThreadStateException异常
控制线程
Join线程

  • Thread提供了一个线程等待另一个线程完成的方法——join()方法。当在某个程序执行流中调用其他线程的join()方法时，调用线程将被阻塞。直到被join()方法加入的join线程执行完为止

  • join()重载形式

    • join() 等待被join的线程执行完成
    • join(long millis)等待被join的线程的时间最长为millis毫秒，如果在millis毫秒内被join的线程还没有执行结束，则不在等待
    • join(long millis,int nanos)等待被join的线程的时间最长为millis毫秒加nanos毫微秒
/**
 * Created by D9ing on 2016/11/14.
 * 线程控制join
 */
public class JoinThread {
    public static void main(String[] args) {
        //创建一个开始线程
        new JoinDemo("新的线程").start();
         TODO: 主线程执行
        for (int i = 0; i < 100; i++) {
            System.out.println(Thread.currentThread().getName() + "执行变量" + i);
            // TODO: join
            if (i == 10) {

                JoinDemo joinThread = new JoinDemo("被join的线程");
                try {
                    joinThread.start();
                    joinThread.join();

                } catch (InterruptedException e) {
                    e.printStackTrace();
                }

            }
        }

    }
}


/**
 * 线程
 */
class JoinDemo extends Thread {


    public JoinDemo(String name) {
        super(name);
    }

    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.println(this.getName() + "执行变量" + i);
        }
    }
}
后台进程(守护线程)
  • 有一种线程,是在后台运行的，为其它的线程提供服务。代表线程JVM的垃圾回收线程
  • 特征：如果所有的前台线程都死亡，后台线程会自动死亡

使用方式

  • 调用Thread对象的setDarmon(true)可将指定线程设置成后台线程。当所有的前台线程死亡时，后台线程也随之死亡。
/**
 * Created by D9ing on 2016/11/14.
 * 后台线程
 */
public class DaemonThreadDemo {
    public static void main(String[] args) {

        // TODO: 创建后台线程
        DaemonThread daemon = new DaemonThread();
        // TODO: 设置后台线程
        daemon.setDaemon(true);
        daemon.start();
        for (int i = 0; i < 100; i++) {
            System.out.println(Thread.currentThread().getName() + "***" + i);
        }
        System.out.println("前台线程结束!!!");
    }
}

class DaemonThread extends Thread {
    @Override
    public void run() {
        for (int i = 0; i < 10000; i++) {
            System.out.println(this.getName() + "---" + i);
        }
        System.out.println("后台线程结束!!!");

    }
}

  • Thread提供 isDarmon()方法，用于判断指定的线程是否为后台线程

  • 关于线程是否是前台线程和后台线程，前台线程创建的子线程为前台线程，后台线程创建的子线程为后台线程

  • 由于所有的前台线程死亡后，JVM会通知后台线程死亡，但接收到死亡通知后需要一定的时间，后台线程设置必须在start()之前调用

线程睡眠

  • 如果需要让当前正在执行的线程暂停一段时间，并进入阻塞状态。可以通过调用Thread类的静态sleep()来实现

  • sleep()重载

    • sleep(long millis):让当前正在执行的线程暂停millis秒，并进入阻塞状态，该方法受到系统计时器和线程调度器的精度与准确度的影响
    • sleep(long millis,int nanos)当前执行的线程暂停millis毫秒加nanos毫微秒,并进入阻塞状态

  • 当当前线程调用sleep()方法进入阻塞状态后，在其睡眠时间内，该线程不会获得执行的机会。即使系统中没有可执行的线程，也不会执行sleep线程

线程让步 yield
  • yield是Thread提供的一个静态方法，它可以让正在执行的线程暂停，但不会阻塞线程。它只是将该线程转入就绪状态，它的根本机制是让当前线程暂停一下，让系统的线程调度器重新调度一次。
  • 实际，当某个线程调用了yield()方法暂停之后，只有优先级与当前线程相同,或者优先级比当前线程高的的处于就绪状态的线程才会获得执行的机会。
线程中断
  • interrupt 中断线程 interrupt会抛出一个异常，终止线程的状态。
  • stop 停止线程 stop会终止线程的执行，无论线程中的执行状态。后面的任何代码都不会被执行。

sleep yield的区别

  • sleep()暂停当前线程后，会给其他线程执行的机会，不会考虑线程的优先级。但yield()只会给优先级相同，或者优先级更高的线程执行的机会

  • sleep()会将线程转入阻塞状态。直到经过阻塞时间才会转入就绪状态。而yield不会将线程转入阻塞状态。它只是强制当前线程进入就绪状态。

  • sleep()方法声明抛出InterruptedException异常，所以调用sleep()要么捕获该异常要么声明抛出异常。

  • sleep()比yield()的可移植性更好

线程的优先级

  • 线程具有一定的优先级，优先级高的线程获得较多的执行机会，优先级低的获得较少的执行机会

  • Thread类提供了setPriority(int newPriority)来设置和返回指定线程的优先级。

    • MAX_PRIORITY 10 最高优先级
    • MIN_PRIORITY 1 最低优先级
    • NORM_PRIORITY 5 普通优先级
线程同步 synchronized关键字
  • 同步的情况

当多线程并发，有多段代码同时执行时，我们希望在某一段代码执行时CPU不要切换到其他的线程 如果两段代码是同步的，那么同一时间只能执行一段，在一段代码没执行结束之前，不会执行另外一段代码 线程的同步问题就是由于线程调度的不确定性引起的。

同步对象(同步锁)
  • 在线程同步中，线程开始执行同步代码块之前，必须先获得同步锁
    • 任何时刻只能有一个线程可以获得同步锁
    • 当同步代码块执行完后，该线程会释放对同步锁的锁定。
    • java程序允许使用任何对象作为同步监视器。
同步代码块
  • 使用synchronized关键字加上一个锁对象来定义一段代码
  • 锁对象可以是任意对象
  • 多个同步代码块如果使用相同的锁对象，那么使用这个相同的锁的代码就是同步的。
/**
 * Created by D9ing on 2016/11/15.
 * 线程让步demo
 */
public class YieldThreadDemo {
    public static void main(String[] args) {

        YieldDemo yieldDemo = new YieldDemo();
        // TODO: 线程一启动
        new Thread() {
            @Override
            public void run() {
                // TODO: 同步控制
                synchronized (yieldDemo) {
                    for (int i = 0; i < 100; i++) {
                        yieldDemo.print1();
                    }
                }
            }
        }.start();
        // TODO: 线程二启动
        new Thread() {
            @Override
            public void run() {
                // TODO: 锁对象
                synchronized (yieldDemo) {

                    for (int i = 0; i < 100; i++) {
                        yieldDemo.print2();
                    }
                }
            }
        }.start();

    }
}


class YieldDemo {
    public void print1() {
        System.out.print("一");
        System.out.print("二");
        System.out.print("三");
        System.out.print("四");
        System.out.print("\r\n");


    }

    public void print2() {
        System.out.print("1");
        System.out.print("2");
        System.out.print("3");
        System.out.print("4");
        System.out.print("\r\n");
    }
}
同步方法

在方法的修饰符中添加Synchronized修饰符

  • 锁对象
    • 非静态的同步方法的锁对象是调用者的对象this
    • 静态的同步方法的锁对象是该类的字节码对象
多线程死锁问题

多线程使用锁嵌套，互相等待释放锁对象就会出现死锁问题
关于线程安全的类

  • Vector 线程安全 ArrayList 线程不安全的
  • StringBuffer 线程安全 StringBuilder 线程不安全
  • Hashtable 线程安全 HashMap 线程不安全
  • 集合类的不安全线程转化 Collections.synchronized(xxx)
同步锁

java5 java提供了——显示定义同步锁对象来实现同步

  • Lock
    • Lock支持多个相关的条件对象
    • 每次只能有一个线程对Lock对象加锁，线程开始访问共享资源之前应该先获得Lock对象 *Lock实现类ReentrantLock(可重入锁) *java8提供了新的StampedLock
  • 使用ReentrantLock代码格式
线程间通信

java提供Object方法来实现线程间通信

  • wait() 、notify()、notifyAll()
    • wait():导致当前线程等待，直到其他线程调用该同步监视器的notify()方法或notifyAll()方法来唤醒线程。该wait()有三种重载形式——无时间参数的wait()[一直等待，直到其他线程通知]、带毫秒参数的wait()、带毫微秒参数的wait()[等待指定时间后自动苏醒]调用wait()方法的当前线程会释放对该同步监视器的锁定
    • notify() 唤醒在此同步监视器上等待的单个线程。如果所有线程都在此同步监视器上等待，则会选择唤醒其中一个线程。选择是任意的，只有当前放弃对该同步监视器的锁定后(wait())，才可以执行被唤醒的线程
    • notifyAll() 唤醒在此同步监视器上等待的所有线程。只有当前线程放弃对该同步监视器的锁定后，才可以执行被唤醒的线程
使用Condition控制线程通信
  • 如果程序中不使用synchronized关键字来同步，而是直接使用Lock对象来保证同步，系统中不存在隐式的同步监视器，也就不能使用wait()、notify()、notifyAll()进行线程通信
  • 当使用Lock来对象来保证同步时，java提供了一个Condition类来保持协调。使用Condition可以让那些已经得到Lock对象却无法继续执行的线程释放Lock对象，Condition对象也可以唤醒其他处于等待的线程
Condition对象通信机制

Condition对象将同步监视器对象的方法(wait()、notity()、notityAll())分解成截然不同的对象，通过将这些对象与Lock对象组合使用，为每个对象提供多个等待集(wait-set) 也就是说，在这种情况下 Lock替代了synchronized同步代码块。Condition替代了同步监视器的功能

  • 步骤
  • 创建Lock锁对象
  • 通过Lock锁对象获取绑定的Condition对象
  • 加锁---> 操作数据 --->操作线程--->释放锁(一般在finally中释放)

API： Condition实例被绑定在一个Lock对象上，要获得特定Lock对象的Condition对象，调用Lock对象的new Condition()方法

  • await() 类似于隐式同步监视器上的wait()方法，导致当前线程等待，直到其他线程调用该Condition的signal()方法或signalAll()方法来唤醒该线程。
  • signal() 唤醒在此Lock对象上等待的单个线程，类似notify(),如果所有的线程都等待，会随机选择一个唤醒只有当前线程放弃对该Lock对象的锁定后，才可以执行被唤醒的线程
  • signalAll() 唤醒在此Lock对象上等待的所有线程
使用阻塞队列(BlockingQueue)
  • java5 提供了一个线程同步的工具接口
  • 当生产者线程向BlockingQueue中放入元素时，如果该队列已满。则线程被阻塞。当消费者师徒从BlockingQueue中取出元素时，如果队列已空，则该线程被阻塞

API:

  • put(E e) 尝试把E元素放入BlockingQueue中，如果该队列的元素已满，则阻塞线程
  • take() 尝试从BlockingQueue的头部取出元素，该队列的元素已空，则阻塞线程
  • 集成Queue()接口的方法
    • add(E e)
    • offer(E e)
    • put(E e)
      需要学习一下队列
线程组和未处理的异常
线程组
  • Java使用ThreadGroup来表示线程组，线程组的作用是可以对一批线程进行管理。
  • 程序对线程组的控制相当于同时控制这批线程。
  • 用户创建的所有线程都属于指定线程组
  • 如果没有显式指定线程属于哪个线程组，则该线程属于默认线程组
  • 默认情况下，子线程和创建它的父线程属于一个线程组
  • 一旦某个线程加入了指定线程组之后，该线程将一直属于该线程组，直到线程死亡，线程运行中不能改变它所属的线程组
API：
  • Thread(ThreadGroup group,Runnable target)：以target的run()方法作为线程执行体创建新线程属于group线程组
  • Thread(ThreadGroup group,Runnable target target,String name)：以target的run()方法作为线程执行体创建新线程，该线程属于group线程组，且线程名为name
  • Thread(ThreadGroup group,String name)创建新线程，新线程名为name,属于group线程组
  • getThreadGroup()返回该线程所属的线程组对象。表示一个线程组
  • ThreadGroup(String name) 以指定的线程组名字来创建新的线程组
  • ThreadGroup(ThreadGroup parent,String name):以指定的名字、指定的父xian'cheng线程组创建一个新线程组
  • int activeCount() 返回此线程组中活动线程的数目
  • interrupt()：中断此线程组中的所有线程
  • isDaemon()判断该线程组是否是守护线程组
  • setDaemom(boolean deamon)设置线程组为后台线程组，当后台线程组的最后一个线程被销毁后，线程组销毁
  • setMaxPriority(int Pri)设置线程组的最高优先级
线程组异常处理

线程组定义了 void uncaughtException(Thread t,Throwable e) 该方法可以处理线程组内的任意线程所抛出的未处理异常

java5开始 线程在执行过程中如果抛出了一个未处理的异常，JVM在结束该线程之前会自动查找是否有对应的Thread.UncaughtExceptionHandler对象，如果找到该处理器对象，则会调用该对象的uncaughtException(Thread t,Throwable e)来处理异常

  • Thread.UncaughtExceptionHandler是Thread类的一个静态内部接口。接口内只有一个方法 void uncaughtException(Thread t,Throwable e)
  • t 代表出现异常的线程
  • e 代表该线程抛出的异常

异常处理

  • static setDefaultUncaughtExcptionHandler(Thread.UncaughtExceptionHandler eh)：为该线程类的所有线程实例设置默认的异常处理器
  • setUncaughtExceptionHandler(Thread.UncaughtExceptionHandler eh)：为指定的线程实例设置异常处理器

由于每个ThreadGroup类实现了Thread.UncaughtExceptionHandler接口，所以每个线程所属的线程组将会作为默认的异常处理器。当一个线程抛出未处理的异常时，JVM会首先查找该异常对应的异常处理器也就是(setUncaughtExceotionHandler()中指定的异常处理器) 如果找到该异常处理器，则将调用该异常处理器处理异常，否则，JVM将会调用该线程所属的线程组对象的uncaughtException()来处理异常 线程组处理异常流程

  1. 如果该线程组有父线程组，则调用父线程组的uncaughtException()来处理异常
  2. 如果该线程实例所属的线程类有默认的异常处理器则调用该异常处理器来处理异常
  3. 如果该异常对象是ThreadDeath对象，则不做任何处理，否则将异常跟踪栈的信息打印到System.err错误输出流，并结束线程

tips:与try...catch区别

  • 当使用catch捕获异常时，异常不会向上传播给上一级调用者
  • 使用异常处理器对异常进行处理后，异常依然会传播给上一级调用者
/**
 * Created by D9ing
 * 2016/11/17
 * Describe:线程的异常处理
 * Todo:
 * Good Luck
 */
public class ExHandlerThread {
    public static void main(String[] args) {
        // TODO: 设置主线程异常处理器
        Thread.currentThread().setUncaughtExceptionHandler(new mExhandler());
        int a = 5 / 0;//除0异常
        System.out.println("线程正常结束");
    }
}

class mExhandler implements Thread.UncaughtExceptionHandler {

    @Override
    public void uncaughtException(Thread t, Throwable e) {
        System.out.println(t + "线程出现了异常" + e);
    }
}
线程池

soource

  • 系统启动一个新线程的成本比较高，这时候应当使用线程池来更好的提高性能。
  • 线程池在系统启动时即创建大量空闲的线程，程序将一个Runnable对象或Callable对象穿给线程池。线程池会启动一个线程来执行他们的run()或者call()，当执行体方法结束后，线程并不会死亡，而是再次返回线程池中成为空闲状态，等待执行下一个Runnable对象的run()或call()方法

在java5，java内建线程池，java5新增了一个Executors工厂类来产生线程池

  • newCachedThreadPool() 创建一个具有缓存功能的线程池，系统根据需要创建线程，这些线程将被缓存在线程池中
  • newFixedThreadPool(int nThreads)创建一个可重用的具有固定线程数的线程池
  • newSingleThreadExceutor() 创建一个只有单线程的线程池==newFixedThreadPool(1)
  • newScheduledThreadPool(int corePoolSize) 创建具有指定线程数的线程池，可以在指定延迟后执行线程任务，corePoolSize指池中锁保存的线程数
  • newSingleThreadScheduledExecutor()创建只有一个线程的线程池，可以在指定延迟后执行线程任务

java8新增

  • ExecutorService new WorkStralingPool(int parallelism) 创建持有足够的线程的线程池来支持给定的并行级别，该方法还会使用多个队列来减少竞争

  • ExecutorService new WorkStealingPool() 创建一个依赖CPU核数的并行数量的线程池

  • ExecutorService 代表一个线程池对象

  • ScheduleExecutorService 是ExecutorService是子类 可以在指定延迟后执行线程任务

ExecutorService代表尽快执行线程的线程池，只要线程池中有空闲线程，就会立即执行线程任务

API 方法 Future<?> submit(Runnable task) 将一个Runnable对象提交给指定的线程池，Future代表Runnable任务的返回值 <T>Future<T>submot(Runnable task,T result)将一个Runnable对象提交给指定的线程池，result显式指定线程执行结束后的返回值，所以Future对象将在run()方法执行结束后返回result <T>Future<T>submit(Callable<T> task) 将一个Callable对象提交给指定的线程池，Future代表Callable中的call()方法的返回值

延迟加载线程池 ScheduleFuture<T>schedule(Callable<V> callable,long delay,TimeUnit unit)指定callable任务将在delay延迟后执行 ScheduleFuture<?>schedule(Runnable command,long delay,TimeUnit unit)指定command任务将在delay延迟后执行 ScheduleFuture<?> scheduleAtFixedRate(Runnable command,long delay,long period,TimeUnit unit)指定command任务将在delay延迟后执行，而且以设定的频率重复执行 ScheduledFuture<?> scheduleWithFixedDelay(Runnable command,long initialDelay,long delay,TimeUnit unit) 创建并执行一个在给定初始延迟后首次启用的定期操作，随后在每一次执行终止和下一次执行开始之间都存在给定的延迟，除非遇到异常，否则只能通过程序显式取消或终止任务

  • 用完一个线程池后，应该调用该线程池的shutdown()方法，该方法将启动线程池的关闭序列，调用shutdown()方法后的线程池不再接受新任务，以前已经提交的任务会执行完成，当线程池中的所有任务都执行完成后，池中所有的线程都会死亡。
  • shutdownNow()该方法试图停止所有正在执行的活动任务，暂停处理正在等待的任务，并返回等待执行的任务列表
使用线程池的步骤
  1. 调用Executors类的静态工厂方法创建一个ExecutorsService对象
  2. 创建Runnable实现类或Callable实现类对象，作为线程执行任务
  3. 调用ExecutorService对象的submit()来提交Runnable对象或Callable对象
  4. 不想提交任何任务时，调用ExecutorService对象的shutdown()方法来关闭线程池
/**
 * Created by D9ing
 * 2016/11/18
 * Describe:线程池测试
 * Todo:
 * Good Luck
 */
public class ThreadPoolTest {

    public static void main(String[] args) {
        ExecutorService executorService = Executors.newFixedThreadPool(6);
        Runnable target = () -> {
            for (int i = 0; i < 100; i++) {
                System.out.println(Thread.currentThread().getName() + "的值为" + i);
            }
        };
        // TODO: 向线程池提交两个线程
        executorService.submit(target);
        executorService.submit(target);
        // TODO: 关闭线程池
        executorService.shutdown();

    }
}
java8增强的ForkJoinPool

  • java7提供了ForkJoinPool来支持将一个任务拆分成多个“小任务”并行计算，再把多个“小任务”的结果合并成总的计算结果

  • ForkJoinPool是ExecuttorService的实现类，是一种特殊的线程池。

    • ForkJoinPool(int p)创建一个包含p个并行线程的ForkJoinPool
    • ForkJoinPool()以Runtime.availableProcessors()方法的返回值作为线程数来创建线程池

  • java8拓展了ForkJoinPool功能，ForkJoinPool增加了通用池的功能

    • ForkJoinPool commonPool() 该方法返回一个通用池，通用池的运行状态不会受shutdown()或shutdownNow()方法的影响。除非程序杀死了进程
    • int getCommonPoolParallelism() 返回通用池的并行级别

  • 再创建了ForkJoinPool实例之后，就可调用ForkJoinPool的submit(ForkJoinTask task)或invoke(ForkJoinTask task)来执行指定任务了。ForkJoinTask代表一个可以并行、合并的任务。

  • ForkJoinTask 是一个抽象类， 有两个抽象子类
    RecursiveAction 没有返回值
    RecursiveTask<T> 有返回值,返回值为泛型T

API:
  • fork() 执行方法
  • join() 当线程结束后返回线程的返回值
/**
 * Created by D9ing
 * 2016/11/18
 * Describe:
 * Todo:
 * Good Luck
 */
public class RecursiveTaskSum {
    public static void main(String[] args) {

        int[] ints = new int[100];
        Random random = new Random();
        int total = 0;
        for (int i = 0, len = ints.length; i < len; i++) {
            int tmp = random.nextInt(20);
            // TODO: 对数组元素赋值,并将数组元素的值添加到sum总和中
            total += (ints[i] = tmp);

        }
        System.out.println(total);
        // TODO: 创建一个通用池
        ForkJoinPool pool = ForkJoinPool.commonPool();
        // TODO: 提交可分解的任务
        Future<Integer> future = pool.submit(new mRecurisveTask(ints, 0, ints.length));
        try {
            System.out.println(future.get());
            pool.shutdown();
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
    }
}

class mRecurisveTask extends RecursiveTask<Integer> {

    // TODO: 定义单次执行的个数
    private static final int THRESHOLD = 20;
    // TODO: 累加的数组
    private int arr[];
    private int start;
    private int end;

    // TODO: 构造器
    public mRecurisveTask(int[] arr, int start, int end) {
        this.arr = arr;
        this.start = start;
        this.end = end;
    }

    @Override
    protected Integer compute() {
        int sum = 0;
        if (end - start < THRESHOLD) {
            for (int i = start; i < end; i++) {
                sum += arr[i];
            }
            return sum;
        } else {
            int middle = (start + end) / 2;
            mRecurisveTask leftTask = new mRecurisveTask(arr, start, middle);
            mRecurisveTask rightTask = new mRecurisveTask(arr, middle, end);
            leftTask.fork();
            rightTask.fork();
            return leftTask.join() + rightTask.join();
        }
    }
}

[java 在多核cpu的强大]

线程相关类

java还位线程安全提供了一些工具类。

  • ThreadLocal 代表一个线程局部变量，把数据放在ThreadLocal中就可以让每个线程创建一个该变量的副本

    • 支持泛型的ThreadLocal<T> 其作用就是每一个线程的局部变量，每个线程都可以保留一个自己的副本，不会和其他线程的副本冲突。
    • ThreadLocal API *T get() 返回此线程局部变量中当前副本中的值 *void remove() 删除此线程局部变量中当前线程副本中的值 *void set(T value) 设置此线程局部变量中当前副本的值

  • 使用建议：如果多个线程之间需要共享资源，以达到线程之间的通信功能，就要使用同步机制。如果仅仅需要隔离多个线程之间的共享冲突，则使用ThreadLocal

包装线程不安全集合
  • Collections 静态方法可以用来包装线程不安全的集合为线程安全的集合
  • Collection<T> synchronizedCollection(Collection<T> c) 返回对应线程安全的collection
  • List synchronizedList 返回指定List对象对应的线程安全List对象
  • Map synchronizedMap 返回指定的Map集合对应的线程安全Map对象
  • set...
  • tree...
线程安全的集合
  • java5 在concurrent 下提供大量支持高效并发访问的集合接口和实现

Concurrent开头的集合类 ConcurrentHashMap、ConcurrentSkipListMap、ConcurrentSkipListSet、ConcurrentLinkedQueue和ConcurrentLinkedDeque

以CopyOnWrite开头 CopyOnWriteArrayList、CopyOnWriteArraySet

  • 以Concurrent开头的集合类代表了支持并发访问的集合。可以支持多个线程并发写入访问。
  • ConcurrentLinkedQueue 实现了多线程的高效。多个线程访问无须等待

Exercise misson 1: 两个线程一个打印1-27 另一个打印A-Z

package com.probuing.learnjavaagain.threadlearn.threadcommexercise;

/**
 * Created by D9ing
 * 2016/11/18
 * Describe:需求 两个线程一个打印1~52 另一个打印A-z
 * Todo:普通线程通信实现
 * Good Luck
 */
public class PrintCommThread {
    public static void main(String[] args) {

        PrintBean bean = new PrintBean("打印");
//        PrintBean bean2 = new PrintBean("打印字母");
        new PrintNumThread(bean).start();
        new PrintLetterThread(bean).start();

    }
}

class PrintBean {
    // TODO: flag
    private boolean flag = true;
    private String name;
    private char[] letter = new char[]{'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z'};

    public PrintBean(String name) {
        this.name = name;
    }

    public synchronized void printNum() {
        for (int i = 1; i < 53; i++) {
            if (!flag) {
                try {
                    wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            System.out.println(name + "线程名:" + Thread.currentThread().getName() + "----" + i);
            flag = false;
            notifyAll();

        }
    }

    public synchronized void printLetter() {
        for (int i = 0; i < letter.length; i++) {
            if (flag) {
                try {
                    wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            System.out.println(name + "线程名:" + Thread.currentThread().getName() + "----" + letter[i]);
            flag = true;
            notifyAll();

        }
    }

}

/**
 * @User:D9ing
 * @Data:上午11:46
 * @describe:打印1~52线程
 * @todo:
 */

class PrintNumThread extends Thread {

    // TODO: 索引bean
    private PrintBean bean;

    public PrintNumThread(PrintBean bean) {
        this.bean = bean;
    }

    @Override
    public void run() {
        bean.printNum();
    }
}

/**
 * @User:D9ing
 * @Data:上午11:56
 * @describe:打印字母线程
 * @todo:
 */

class PrintLetterThread extends Thread {
    private PrintBean bean;

    public PrintLetterThread(PrintBean bean) {
        this.bean = bean;
    }

    @Override
    public void run() {
        bean.printLetter();
    }
}
  • Lock锁实现
package com.probuing.learnjavaagain.threadlearn.threadcommexercise;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

/**
 * Created by D9ing
 * 2016/11/18
 * Describe:两个线程 一个打印1-27 另一个打印A-z
 * Todo:java8 Lock实现
 * Good Luck
 */
public class PrintCommLock {
    public static void main(String[] args) {

        LockBean bean = new LockBean("打印实体");
        // TODO: 普通线程构造
//        new Thread(new PrintNumThreadLock(bean)).start();
//        new Thread(new PrintLetterThreadLock(bean)).start();
        // TODO: 线程池
        ExecutorService executorService = Executors.newFixedThreadPool(4);
        executorService.submit(new PrintNumThreadLock(bean));
        executorService.submit(new PrintLetterThreadLock(bean));

//        executorService.submit(new )

    }
}

/**
 * @User:D9ing
 * @Data:下午12:34
 * @describe: Lock实体
 * @todo:
 */

class LockBean {
    private final Lock lock = new ReentrantLock();
    private final Condition cond = lock.newCondition();
    private char[] letter = new char[]{'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z'};
    private String name;
    private boolean flag = true;

    public LockBean(String name) {
        this.name = name;
    }

    /*
    打印数字方法
     */
    public void printNum() {
        // TODO: 加锁
        lock.lock();
        try {
            for (int i = 0; i < letter.length; i++) {
                if (!flag) {
                    cond.await();
                }
                System.out.println(Thread.currentThread().getName() + "---" + i);
                flag = false;
                // TODO: 唤醒线程
                cond.signalAll();
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            // TODO: 释放锁
            lock.unlock();
        }

    }

    public void printLetter() {
        // TODO: 加锁
        lock.lock();
        try {
            for (int i = 0; i < letter.length; i++) {
                if (flag) {
                    // TODO: 线程等待
                    cond.await();
                }
                System.out.println(Thread.currentThread().getName() + "---" + letter[i]);
                flag = true;
                // TODO: 唤醒线程
                cond.signalAll();

            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }

}

class PrintNumThreadLock implements Runnable {
    private LockBean bean;

    public PrintNumThreadLock(LockBean bean) {
        this.bean = bean;
    }

    @Override
    public void run() {
        bean.printNum();

    }
}

class PrintLetterThreadLock implements Runnable {

    private LockBean bean;

    public PrintLetterThreadLock(LockBean bean) {
        this.bean = bean;
    }

    @Override
    public void run() {
        bean.printLetter();
    }
}
ProbuINg
关注
专栏目录
Fork\Join分而治之--RecursiveTask和RecursiveAction（一）
qq_32445069的博客
07-30 1457
fork/join 分而治之 1.什么是Fork/join框架？ 从JDK1.7开始，Java提供Fork/Join框架用于并行执行任务。它的思想就是讲一个大任务分割成若干小任务，最终汇总每个小任务的结果得到这个大任务的结果。如下图： 2.什么是分而治之思想 可以简单的理解为：将规模为N的问题，当N<阈值，直接解决；当N>阈值，将N分解为K个小规模子问题，子问题互相对立，与原问题形式...
『图解Java并发编程系列』10张图告诉你Java并发多线程那些破事
华科硕士，大厂打工中。编程问题咨询，请私我
04-28 1万+
头发很多的程序员：『师父，这个批量处理接口太慢了，有什么办法可以优化？』 架构师：『试试使用多线程优化』 第二天 头发很多的程序员：『师父，我已经使用了多线程，为什么接口还变慢了？』 架构师：『去给我买杯咖啡，我写篇文章告诉你』 ……吭哧吭哧买咖啡去了 在实际工作中，错误使用多线程非但不能提高效率还可能使程序崩溃。以在路上开车为例： 在一个单向行驶的道路上，每辆汽车都遵守交通规则，这时候整体通行是正常的。『单向车道』意味着『一个线程』，『多辆车』意味着『多个job任务』。 单线程顺利.
Java工程师成神之路
kongjiea笔记
12-11 1878
一、基础篇 1.1 JVM 1.1.1. Java内存模型，Java内存管理，Java堆和栈，垃圾回收 http://www.jcp.org/en/jsr/detail?id=133 http://ifeve.com/jmm-faq/ 1.1.2. 了解JVM各种参数及调优 1.1.3. 学习使用Java工具 jps, jstack, jmap,
用Java撸一下LFU简易版本
weixin_43272605的博客
02-19 2万+
最近在别人文章看到一片关于LFU的题目，个人觉得实现可以不同，他用的c，那我用java写一下，毕竟c已经忘的差不多了。 那个题就是让我们来设计一个数据结构，使其能够按照key-value的方式来实现put和get，而且要满足LFU，而且在空间满了之后，又要满足最近最少使用即LRU，且操作时间复杂度要满足O(1) 首先看看什么是LFU LFU(Leatest Frequently Used)即访问频...
Java进阶之路——从初级程序员到架构师，从小工到专家
热门推荐
盛飞的专栏
07-20 7万+
文章首发在我的微信公众号：Java北京(java_bj)，欢迎关注。 怎样学习才能从一名Java初级程序员成长为一名合格的架构师，或者说一名合格的架构师应该有怎样的技术知识体系，这是不仅一个刚刚踏入职场的初级程序员也是工作三五年之后开始迷茫的老程序员经常会问到的问题。希望这篇文章会是你看到过的最全面最权威的回答。 一： 编程基础 不管是C还是C++，不管是Java还是PHP，想成为一名合格的...
Java大神修炼之路
huaieli1的博客
01-17 2662
        一、基础篇 　　1.1 JVM 　　1.1.1. Java内存模型，Java内存管理，Java堆和栈，垃圾回收 　　http://www.jcp.org/en/jsr/detail?id=133 　　http://ifeve.com/jmm-faq/ 　　1.1.2. 了解JVM各种参数及调优 　　1.1.3.
Java Swing大神必经之路
最新发布
11-08
第3篇 Java Swing大神必经之路3：JavaSwing-AbstractButton详解 本篇文章对 AbstractButton 进行了详细的介绍，包括其定义、构造方法、setParameter() 等，幫助讀者更好地理解 AbstractButton 的使用。 第4篇 Java ...
Java并发：创建线程的两种方法：继承Thread类和实现Runnable接口（一）
区块链之美
04-09 1万+
【1】了解进程与线程的概念 进程是一个程序在其自身的地址空间中执行一次活动，是资源申请、调度和独立运行的单位。 线程是进程中的一个单一的连续控制流程，一个进程可以包含一个或多个线程。 如果要在一个程序中实现多段代码同时交替运行，就需要产生多个线程，并指定每个线程上要运行的程序代码段，这就是多线程。 当程序运行时，就自动产生了一个线程，主函数main就是在这个线程上运行的，当不再产生新的线程时，...
JAVA多线程之两个线程同时写一个文件
qq_32971807的博客
08-04 2万+
1.多线程    线程是程序执行流的最小单元。是进程中的一个实体，是被系统独立调度和分派的基本单位，线程自己不拥有系统资源，只拥有一点儿在运行中必不可少的资源，但它可与同属一个进程的其它线程共享进程所拥有的全部资源。一个线程可以创建和撤消另一个线程，同一进程中的多个线程之间可以并发执行。由于线程之间的相互制约，致使线程在运行中呈现出间断性。线程也有就绪、阻塞和运行三种基本状态。就绪状态是指线程具备
JAVA实战之路（8）：IDEA使用小技巧：IDEA禁止import *和允许import内部类
theonesmx的博客
11-18 2346
IDEA 禁止import * 和允许import内部类
一个JAVA程序员成长之路分享
u013659231的博客
05-26 2万+
我搞JAVA也有些日子了, 因为我比较贪玩,上进心不那么强, 总是逼不得已为了高薪跳槽才去学习, 所以也没混成什么大牛, 但好在现在也已经成家立业, 小日子过的还算滋润, 起码顶得住一月近万元的吃喝拉撒玩各种贷款信用卡 不为金钱过于发愁了。 我特别感谢当初贴吧遇见的那位大神, 虽然每个月也就聊那么几句, 但是他总能在我不知道该学啥, 该怎么走的时候, 给我方向, 毫不夸张的说,我现在的衣食无忧,
Java8 RecursiveTask实现forkjoin
周莫客的博客
12-29 271
package com.mock; import org.junit.jupiter.api.Test; import java.util.concurrent.ForkJoinPool; import java.util.concurrent.RecursiveTask; public class TestForkJoinCalculate { @Test public ...
ForkJoin并发框架—样例及实现分析
男儿当自强
05-14 1875
1. JDK中ForkJoin实现概述在JavaSE7的API和JDK1.7中，分别集成了支持ForkJoin的五个类： ForkJoinPool 实现ForkJoin的线程池 ForkJoinWorkerThread 实现ForkJoin的线程 ForkJoinTask 一个描述ForkJoin的抽象类 RecursiveAction 无返回结果的ForkJoinTask实现 Recursive
Java大神之路第八季Spring5项目实战(完整)
weixin_44878864的博客
04-18 2410
01_Spring课程和老师介绍【录播】01_Spring课程和老师介绍(7分钟) 免费试学0202_丑陋的代码【录播】02_丑陋的代码(12分钟)0303_Spring的崛起【录播】03_Spring的崛起(14分钟)0404_Spring帝国【录播】04_Spring帝国(19分钟)0505_IoC和DI思想【录播】05_IoC和DI思想(14分钟)0606_Spring的HelloWorld...
Java进击之路——成为JAVA大神你必须完成的30个目标（包括核心思想，核心类库，核心技术等)
kingscoming的博客
12-19 907
Java进击之路——成为JAVA大神你必须完成的30个目标我在下面罗列了30个学习JAVA的目标，包括java核心编程思想，核心类库，核心技术及其他相关技术等，相信当你掌握这些思想和技术时，你已经是一个受人膜拜的java大神了。
Java学习之路：从新手到入门的实战建议
"大神学习Java建议" 学习Java的过程可以分为多个阶段，从基础入门到逐渐精通。以下是我根据个人经验总结的一些关键点，希望能对新手或想要转行的朋友提供帮助。 首先，掌握Java的基础至关重要。这包括理解并熟练...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值