第4节多线程 - 多线程 - 《JavaEE学习笔记》

进程
线程
线程调度
- 分时调度
- 抢占式调度
同步与异步
并发与并行
继承Thread
- 字段
- 方法摘要
实现Runnable
线程池 Executors
- 线程池的好处
- Java中的四种线程池 . ExecutorService
Lambda表达式

进程

指一个内存中运行的应用程序，一个进程独占一个独立的空间。

线程

是进程中的一个执行路径，共享一个内存空间，线程之间可以自由切换，并发执行，一个进程最少有一个线程。
线程实际上是在进程基础上的进一步划分，一个进程执行后，里面的若干执行路径又可以划分成若干个线程

线程调度

分时调度

所有线程轮流使用cpu，平均分配每个线程占用cpu的时间。

抢占式调度

优先让优先级高的线程使用cpu，如果优先级相同就随机分配，java用的是抢占式调度。

CPU使用抢占式调度模式在多个线程间进行着高速的切换。对于CPU的一个核新而言，某个时刻，
只能执行一个线程，而 CPU的在多个线程间切换速度相对我们的感觉要快，看上去就是在同一时
刻运行。其实，多线程程序并不能提高程序的运行速度，但能够提高程序运行效率，让CPU的使
用率更高。

同步与异步

同步：排队执行，效率低但安全
异步：同时执行，效率高但不安全

并发与并行

并发：多个事情在同一时间段执行
并行：多个事情在同一时刻执行

继承Thread

有两种方法可以创建新的执行线程。一种是将类声明为Thread的子类。此子类应覆盖类Thread的run方法。然后可以分配和启动子类的实例。
当在某个线程中运行的代码创建一个新的Thread对象时，新线程的优先级最初设置为等于创建线程的优先级，并且当且仅当创建线程是守护进程时才是守护进程线程。
每个线程都有自己的栈空间，共享一个堆空间。由一个线程所调用的方法，这个方法会在这个线程里执行。

字段

变量和类型	字段	描述
`static int`	`[MAX_PRIORITY](#MAX_PRIORITY)`	线程可以拥有的最大优先级。
`static int`	`[MIN_PRIORITY](#MIN_PRIORITY)`	线程可以拥有的最低优先级。
`static int`	`[NORM_PRIORITY](#NORM_PRIORITY)`	分配给线程的默认优先级。

方法摘要

变量和类型	方法	描述
`static int`	`[activeCount](#activeCount())()`	返回当前线程thread group及其子组中活动线程数的估计值。
`void`	`[checkAccess](#checkAccess())()`	确定当前运行的线程是否具有修改此线程的权限。
`protected [Object](Object.html)`	`[clone](#clone())()`	抛出CloneNotSupportedException，因为无法有意义地克隆线程。
`int`	`[countStackFrames](#countStackFrames())()`	不推荐使用，要删除：此API元素将在以后的版本中删除。此调用的定义取决于`suspend()`) ，已弃用。
`static [Thread](Thread.html)`	`[currentThread](#currentThread())()`	返回对当前正在执行的线程对象的引用。
`static void`	`[dumpStack](#dumpStack())()`	将当前线程的堆栈跟踪打印到标准错误流。
`static int`	`[enumerate](#enumerate(java.lang.Thread%5B%5D))([Thread](Thread.html)[] tarray)`	将当前线程的线程组及其子组中的每个活动线程复制到指定的数组中。
`static [Map](../util/Map.html)<[Thread](Thread.html),[StackTraceElement](StackTraceElement.html)[]>`	`[getAllStackTraces](#getAllStackTraces())()`	返回所有活动线程的堆栈跟踪映射。
`[ClassLoader](ClassLoader.html)`	`[getContextClassLoader](#getContextClassLoader())()`	返回此线程的上下文 `ClassLoader` 。
`static [Thread.UncaughtExceptionHandler](Thread.UncaughtExceptionHandler.html)`	`[getDefaultUncaughtExceptionHandler](#getDefaultUncaughtExceptionHandler())()`	返回由于未捕获的异常而导致线程突然终止时调用的默认处理程序。
`long`	`[getId](#getId())()`	返回此Thread的标识符。
`[String](String.html)`	`[getName](#getName())()`	返回此线程的名称。
`int`	`[getPriority](#getPriority())()`	返回此线程的优先级。
`[StackTraceElement](StackTraceElement.html)[]`	`[getStackTrace](#getStackTrace())()`	返回表示此线程的堆栈转储的堆栈跟踪元素数组。
`[Thread.State](Thread.State.html)`	`[getState](#getState())()`	返回此线程的状态。
`[ThreadGroup](ThreadGroup.html)`	`[getThreadGroup](#getThreadGroup())()`	返回此线程所属的线程组。
`[Thread.UncaughtExceptionHandler](Thread.UncaughtExceptionHandler.html)`	`[getUncaughtExceptionHandler](#getUncaughtExceptionHandler())()`	返回此线程由于未捕获的异常而突然终止时调用的处理程序。
`static boolean`	`[holdsLock](#holdsLock(java.lang.Object))([Object](Object.html) obj)`	当且仅当当前线程在指定对象上保存监视器锁时，返回 `true` 。
`void`	`[interrupt](#interrupt())()`	中断此线程。
`static boolean`	`[interrupted](#interrupted())()`	测试当前线程是否已被中断。
`boolean`	`[isAlive](#isAlive())()`	测试此线程是否存活。
`boolean`	`[isDaemon](#isDaemon())()`	测试此线程是否为守护程序线程。
`boolean`	`[isInterrupted](#isInterrupted())()`	测试此线程是否已被中断。
`void`	`[join](#join())()`	等待这个线程死亡。
`void`	`[join](#join(long))(long millis)`	此线程最多等待 `millis`毫秒。
`void`	`[join](#join(long,int))(long millis, int nanos)`	此线程最多等待 `millis`毫秒加上 `nanos`纳秒。
`static void`	`[onSpinWait](#onSpinWait())()`	表示调用者暂时无法进展，直到其他活动发生一个或多个操作为止。
`void`	`[resume](#resume())()`	已过时。此方法仅适用于`suspend()`) ，由于它易于死锁，因此已被弃用。
`void`	`[run](#run())()`	如果此线程是使用单独的`Runnable`运行对象构造的，则调用该`Runnable`对象的`run`方法; 否则，此方法不执行任何操作并返回。
`void`	`[setContextClassLoader](#setContextClassLoader(java.lang.ClassLoader))([ClassLoader](ClassLoader.html) cl)`	为此Thread设置上下文ClassLoader。
`void`	`[setDaemon](#setDaemon(boolean))(boolean on)`	将此线程标记为 daemon)线程或用户线程。
`static void`	`[setDefaultUncaughtExceptionHandler](#setDefaultUncaughtExceptionHandler(java.lang.Thread.UncaughtExceptionHandler))([Thread.UncaughtExceptionHandler](Thread.UncaughtExceptionHandler.html) eh)`	设置当线程由于未捕获的异常而突然终止时调用的默认处理程序，并且没有为该线程定义其他处理程序。
`void`	`[setName](#setName(java.lang.String))([String](String.html) name)`	将此线程的名称更改为等于参数 `name` 。
`void`	`[setPriority](#setPriority(int))(int newPriority)`	更改此线程的优先级。
`void`	`[setUncaughtExceptionHandler](#setUncaughtExceptionHandler(java.lang.Thread.UncaughtExceptionHandler))([Thread.UncaughtExceptionHandler](Thread.UncaughtExceptionHandler.html) eh)`	设置当此线程由于未捕获的异常而突然终止时调用的处理程序。
`static void`	`[sleep](#sleep(long))(long millis)`	导致当前正在执行的线程休眠（暂时停止执行）指定的毫秒数，具体取决于系统计时器和调度程序的精度和准确性。
`static void`	`[sleep](#sleep(long,int))(long millis, int nanos)`	导致当前正在执行的线程休眠（暂时停止执行）指定的毫秒数加上指定的纳秒数，具体取决于系统定时器和调度程序的精度和准确性。
`void`	`[start](#start())()`	导致此线程开始执行; Java虚拟机调用此线程的`run`方法。
`[String](String.html)`	`[toString](#toString())()`	返回此线程的字符串表示形式，包括线程的名称，优先级和线程组。
`static void`	`[yield](#yield())()`	向调度程序提示当前线程是否愿意产生其当前使用的处理器。

public class Demo1 {
    /**
     * 多线程技术
     * @param args
     */
    public static void main(String[] args) {
        MyTherd  m = new MyTherd();
        m.start();
        for(int i = 0; i < 10 ;i++){
            System.out.println("B");
        }
    }
}

public class MyTherd extends Thread {
    /**
     * run方法就是线程要执行的任务方法
     *
     */
    @Override
    public void run() {
        //这里的代码，就是一个新的执行路劲
        //执行路劲的调用方式，通过therd对象的start()来启动rw
        for(int i = 0; i < 10 ;i++){
            System.out.println("A");
        }

    }

实现Runnable

实现Runnable通过实例化Thread实例并将其自身作为目标传递而无需子类化Thread 。在大多数情况下，如果您只打算覆盖run()方法而不使用其他Thread方法，则应使用Runnable接口。

**
* 用于给线程执行的任务
*/
public class Myrunnable implements Runnable {
  @Override
  public void run() {
      //线程的任务
      for(int i = 0; i < 10;i++){
          System.out.println("A");
      }

  }
}

``` ublic class Demo2 { public static void main(String[] args) {

  //创建一个任务对象
  Myrunnable r = new Myrunnable();
  //创建一个线程，并为其分配任务m
  Thread t = new Thread(r);
  //执行线程
  t.start();
  for(int i = 0; i < 10;i++){
      System.out.println("B");
  }

} }

<a name="o0Cdi"></a>
### 实现Runnable接口比继承Therd有如下优势：
1.通过创建任务，通过给线程分配的方式来实现多线程，更适合多个线程同时执行相同任务的情况。<br />2.可避免单继承带来的局限性<br />3.任务与线程本身是分开的，提高了程序的健壮性<br />4.线程池计数接受Runnable

<a name="0dpnn"></a>
## 设置和获取线程名称
| `static [Thread](Thread.html)` | `[currentThread](#currentThread())()` | 返回对当前正在执行的线程对象的引用。  |
| --- | --- | --- |

| `[String](String.html)` | `[getName](#getName())()` | 返回此线程的名称。  |
| --- | --- | --- |

public class Demo3 { public static void main(String[] args) { System.out.println(Thread.currentThread().getName()); new Thread(new MyRunnable(),”1号”).start();//设置名称 Thread thread = new Thread(new MyRunnable()); thread.setName(“2号”); thread.start(); new Thread(new MyRunnable()).start(); //结果： // main // 1号 // 2号 // Thread-1 } static class MyRunnable implements Runnable{

    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName());//返回当前线程的名称
    }
}

}


<a name="QsKE3"></a>
## 线程休眠
| `static void` | `[sleep](#sleep(long))(long millis)` | 导致当前正在执行的线程休眠（暂时停止执行）指定的毫秒数，具体取决于系统计时器和调度程序的精度和准确性。  |
| --- | --- | --- |
| `static void` | `[sleep](#sleep(long,int))(long millis, int nanos)` | 导致当前正在执行的线程休眠（暂时停止执行）指定的毫秒数加上指定的纳秒数，具体取决于系统定时器和调度程序的精度和准确性。  |

public class Democratic { public static void main(String[] args) throws InterruptedException { for(int i = 0; i < 10; i++){ System.out.println(i); Thread.sleep(1000); //结果：每隔1s输出一个i } } }

<a name="feUuk"></a>
## 线程阻塞
表示线程当前暂停执行的状态

<a name="XFF5o"></a>
## 线程的中断
一个线程是否中断，由其自身决定。

public class Demo3 { public static void main(String[] args) {
Thread t1 = new Thread(new MyRunnable());
t1.start(); for(int i = 0; i < 5;i++){ System.out.println(Thread.currentThread().getName()+i); try { Thread.sleep(1000); } catch (InterruptedException e) { e.printStackTrace(); } } //给线程t1添加中断笔记 t1.interrupt(); //结果：Thread-00 //main0 //main1 //Thread-01 //Thread-02 //main2 //Thread-03 //main3 //main4 //Thread-04 //Thread-05 //中断

}
static class  MyRunnable implements Runnable{

    @Override
    public void run() {
       for(int i = 0; i < 10;i++){
           System.out.println(Thread.currentThread().getName()+i);
           try {
               Thread.sleep(1000);
           } catch (InterruptedException e) {

// e.printStackTrace(); //通过return中断 System.out.println(“中断”); return; } } } } }


<a name="GJKxh"></a>
## 守护线程
线程可分为用户线程(user thread) 和 守护线程(daemon thread)。<br />守护线程指在后台运行的线程，也称为后台线程，用于提供后台服务。<br />Java创建的线程默认是用户线程。<br />守护线程：当一个进程不含任务用户线程时，进程结束<br />守护线程：守护用户线程的，最后一个用户线程结束时，所有守护线程自动死亡

public class Demo3 { public static void main(String[] args) { Thread t1 = new Thread(new MyRunnable()); //通过t1.setDaemon(true);设置t1为守护线程 t1.setDaemon(true); t1.start(); for(int i = 0; i < 5;i++){ System.out.println(Thread.currentThread().getName()+i); try { Thread.sleep(1000); } catch (InterruptedException e) { e.printStackTrace(); } } } static class MyRunnable implements Runnable{

    @Override
    public void run() {
       for(int i = 0; i < 10; i++){
           System.out.println(Thread.currentThread().getName()+i);
           try {
               Thread.sleep(1000);
           } catch (InterruptedException e) {
               e.printStackTrace();

// 结果： // Thread-00 // main0 // main1 // Thread-01 // main2 // Thread-02 // Thread-03 // main3 // main4 // Thread-04 // Thread-05

}

<a name="D754C"></a>
## 线程安全

3个线程同时启动同时对count--进行操作出现了余票为-1的情况