实现多线程的两种方式

一、线程详解：

程序是为完成特定任务、用某种语言编写的一组指令的集合。即指一段静态的代码，静态对象。

进程是程序的一次执行过程，或是正在运行的一个程序。是一个动态的过程：有它自身的产生、存在和消亡的过程。  --生命周期

进程作为资源分配的单位，系统在运行时会为每个进程分配不同的内存区域。

在操作系统中运行的程序就是进程，比如你的qq，播放器，游戏，IDE等等。。。

一个进程可以有多个线程，如视频中同时听声音，看图像，看弹幕，等等

说起进程，就不得不说下程序。程序是指令和数据的有序集合，其本身没有任何运行的含义，是一个静态的概念。

而进程则是执行程序的一次执行过程，它是一个动态的概念。是系统资源分配的单位

通常在一个进程中可以包含若干个线程，当然一个进程中至少有一个线程，叫main线程，不然没有存在的意义。线程是CPU调度和执行的单位。

线程作为调度和执行的单位，每个线程拥有独立的运行栈和程序计数器（pc),线程切换的开销小。

注意：很多线程是模拟出来的，真正的多线程是指有多个cpu,即多核，如服务器。如果是模拟出来的多线程，即在一个cpu的情况下，在同一个时间点，cpu只能执行一个代码，因为切换的很快，所以就有同时执行的错觉。

不同进程用不同的方法区和堆。

多个线程共享方法区和堆（调优主要调这里，进行优化），多个线程有不同的虚拟机栈和程序计数器。

核心概念：

线程就是独立的执行路径

在程序运行时，即使没有自己创建线程，后台也会有多个线程，如主线程，gc线程（垃圾回收的线程）、异常处理线程。当然如果发生异常，会影响主线程。

main()称之为主线程，为系统的入口，用于执行整个程序。

在一个进程中，如果开辟了多个线程，线程的运行由调度器（CPU）安排调度，调度器是与操作系统紧密相关的，先后顺序是不能人为的干预的。

对同一份资源操作时，会存在资源抢夺的问题，需要加入并发控制。

线程会带来额外的开销，如cpu调度时间，并发控制开销。

每个线程在自己的工作内存交互，内存控制不当会造成数据不一致。

并行：多个CPU同时执行多个任务。

并发：一个CPU（采用时间片）同时执行多个任务。

多线程程序的优点：

1.提高应用程序的响应，对图形化界面更有意义，可增强用户体验

2.提高计算机系统CPU的利用率。

3.改善程序结构。将既长又复杂的进程分为多个线程，独立运行，利于理解和修改。

何时需要多线程：

1.程序需要同时执行两个或多个任务

2.程序需要实现一些需要等待的任务时，如用户输入、文件读写操作、网络操作、搜索等。

3.需要一些后台运行的程序时。

线程的创建：

java语言的JVM允许程序运行多个线程，它通过java.lang.Thread类来实现。

Thread class 继承Thread(重点）

Runnable接口 实现Runnable(重点）

Callable接口 实现Callable接口（了解）

Thread：

Thread类的特性：

每个线程都是通过某个特定Thread对象的run()方法来完成操作的，经常把run（）方法的主体称为线程体。

Thread类的有关方法：

void start :启动线程，并执行对象的run()方法

run():线程在被调度时执行的操作

String getName():返回线程的名称

void setName(String name):设置该线程名称

static Thread currentThread():返回当前线程。在Thread子类中就是this,通常用于主线程和Runnable实现类。

我们来测试这些方法如下所示：

package com.ypl.exercise;

/**
 * 测试Thread中的常用方法
 * 1.start（）：启动当前线程，调用当前线程的run（）
 * 2.run:通常需要重写Thread类中的此方法，将创建的线程要执行的操作声明在此方法中。
 * 3.currentThread():静态方法，返回执行当前代码的线程。
 * 4.getName():获取当前线程的名字
 * 5.setName():设置当前线程的名字
 */

class HelloThread extends Thread{
    @Override
    public void run() {
        for(int i=0;i<100;i++){
            if(i %2== 0){
                System.out.println(Thread.currentThread().getName()+":"+i);
            }

        }
    }
}
public class ThreadMethodTest {
    public static void main(String[] args) {
        HelloThread h1 = new HelloThread();
        h1.start();
    }
}

 我们运行之后如下所示：

我们进入底层源码发现如下所示：

 public Thread(Runnable target) {
        init(null, target, "Thread-" + nextThreadNum(), 0);
    }

我们对线程进行修改名字：

package com.ypl.exercise;

/**
 * 测试Thread中的常用方法
 * 1.start（）：启动当前线程，调用当前线程的run（）
 * 2.run:通常需要重写Thread类中的此方法，将创建的线程要执行的操作声明在此方法中。
 * 3.currentThread():静态方法，返回执行当前代码的线程。
 * 4.getName():获取当前线程的名字
 * 5.setName():设置当前线程的名字
 */

class HelloThread extends Thread{
    @Override
    public void run() {
        for(int i=0;i<100;i++){
            if(i %2== 0){
                System.out.println(Thread.currentThread().getName()+":"+i);
            }

        }
    }
}
public class ThreadMethodTest {
    public static void main(String[] args) {
        HelloThread h1 = new HelloThread();
        h1.setName("线程一");
        h1.start();
        //给主线程命名
        Thread.currentThread().setName("主线程");
        for(int i=0;i<100;i++){
            if(i %2== 0){
                System.out.println(Thread.currentThread().getName()+":"+i);
            }

        }
    }
}

 运行之后如下所示：

我们也可以利用构造器来进行修改名字：

 public Thread(String name) {
        init(null, null, name, 0);
    }

 我们示例如下所示：

package com.ypl.exercise;

/**
 * 测试Thread中的常用方法
 * 1.start（）：启动当前线程，调用当前线程的run（）
 * 2.run:通常需要重写Thread类中的此方法，将创建的线程要执行的操作声明在此方法中。
 * 3.currentThread():静态方法，返回执行当前代码的线程。
 * 4.getName():获取当前线程的名字
 * 5.setName():设置当前线程的名字
 */

class HelloThread extends Thread{
    @Override
    public void run() {
        for(int i=0;i<100;i++){
            if(i %2== 0){
                System.out.println(Thread.currentThread().getName()+":"+i);
            }

        }
    }
    public HelloThread(String name){
        super(name);
    }
}
public class ThreadMethodTest {
    public static void main(String[] args) {
        HelloThread h1 = new HelloThread("Thread：1");
        //   h1.setName("线程一");
        h1.start();
        //给主线程命名
        Thread.currentThread().setName("主线程");
        for(int i=0;i<100;i++){
            if(i %2== 0){
                System.out.println(Thread.currentThread().getName()+":"+i);
            }

        }
    }
}

运行之后如下所示：

 

 其他方法我们如下所示：
 

package com.ypl.exercise;

/**
 * 测试Thread中的常用方法
 * 1.start（）：启动当前线程，调用当前线程的run（）
 * 2.run:通常需要重写Thread类中的此方法，将创建的线程要执行的操作声明在此方法中。
 * 3.currentThread():静态方法，返回执行当前代码的线程。
 * 4.getName():获取当前线程的名字
 * 5.setName():设置当前线程的名字
 * 6.yield():释放当前cpu的执行权，也有可能在下一刻又分配到当前的线程
 * 7.join():在线程a中调用线程b的join（），此时线程a就进入阻塞状态，直到线程b完全执行完以后，线程a才结束阻塞状态。
 * 8.stop():已过时，当执行此方法时，强制结束当前线程强。
 * 9.sleep(long millitime):让当前线程“睡眠”指定的millitime毫秒，在指定的millitime毫秒时间内，当前线程是阻塞状态。
 * 10.isAlive():判断当前线程是否存活
 */

class HelloThread extends Thread{
    @Override
    public void run() {
        for(int i=0;i<100;i++){
            if(i %2== 0){
                try {
                    sleep(10);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName()+":"+i);
            }
            if(i%20==0){
                yield();
            }

        }
    }
    public HelloThread(String name){
        super(name);
    }
}
public class ThreadMethodTest {
    public static void main(String[] args) {
        HelloThread h1 = new HelloThread("Thread：1");
        //   h1.setName("线程一");
        h1.start();
        //给主线程命名
        Thread.currentThread().setName("主线程");
        for(int i=0;i<100;i++){
            if(i %2== 0){
                System.out.println(Thread.currentThread().getName()+":"+i);
            }
            if(i==20){
                try {
                    h1.join();
                } catch (InterruptedException e) {
                 e.printStackTrace();
                }
            }

        }
        System.out.println(h1.isAlive());
    }
}

运行之后如下所示：

 

 线程的调度：

调度策略：

时间片：执行一段这个线程，执行一段另一个线程。

抢占式：高优先级的线程抢占CPU

java的调度方法：

同优先级线程组成先进先出队列（先到先服务），使用时间片策略

对高优先级，使用优先调度的抢占式策略。

线程的优先级等级：

MAX_PRIORITY:10

MAX_PRIORITY:1

MAX_PRIORITY:5

涉及的方法：

getPriority():返回线程优先值

setPriority(int newPriority):改变线程的优先级

我们如下所示：

一、Thread class 继承Thread(重点） 

自定义线程类继承Thread类

重写run（）方法，编写线程执行体

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

调用start方法，两条线程同时执行的。

线程不一定立即执行，CPU安排调度，所以每次执行的结果可能会不同

示例一：

package com.hy;

/**
 * 多线程的创建：方式一：继承于Thread类
 * 1.创建一个继承于Thread类的子类
 * 2.重写Thread类的run（）-->将此线程执行的操作声明在run()中
 * 3.创建Thread类的子类的对象
 * 4.通过此对象调用start()方法
 * 例子：遍历100以内所以的偶数
 */

//1.创建一个继承于Thread类的子类
class MyThead extends Thread {

    // 2.重写Thread类的run（）
    public void run() {
        for (int i = 0; i <= 100; i++) {
            if (i % 2 == 0) {
                System.out.println(i);
            }
        }
    }
}
public class ThreadTest {
   //3.创建Thread类的子类的对象
   public static void main(String[] args) {
       //3.创建Thread类的子类的对象
       MyThead myThead = new MyThead();
       //4.通过此对象调用start()方法：（1）启动当前线程（2）调用当前线程的run()
       myThead.start();
      //如下操作仍然是在main线程中执行的。
       for (int i = 0; i <= 100; i++) {
               if (i % 2 == 0) {
                   System.out.println(i+"*********main()*********");
               }
           }

   }
    }

运行之后如下所示：

 

示例二：

package com.hy;

/**
 * 多线程的创建：方式一：继承于Thread类
 * 1.创建一个继承于Thread类的子类
 * 2.重写Thread类的run（）-->将此线程执行的操作声明在run()中
 * 3.创建Thread类的子类的对象
 * 4.通过此对象调用start()方法
 * 例子：遍历100以内所以的偶数
 */

//1.创建一个继承于Thread类的子类
class MyThead extends Thread {

    // 2.重写Thread类的run（）
    public void run() {
        for (int i = 0; i <= 100; i++) {
            if (i % 2 == 0) {
                System.out.println(Thread.currentThread().getName()+":"+i);
            }
        }
    }
}
public class ThreadTest {
   //3.创建Thread类的子类的对象
   public static void main(String[] args) {
       //3.创建Thread类的子类的对象
       MyThead myThead = new MyThead();
       //4.通过此对象调用start()方法
       myThead.start();
       //问题一：我们不能通过直接调用run（）的方式启动线程
      // myThead.run();

       //问题二：再启动一个线程，遍历100以内的偶数,不可以让已经start()的线程去执行，会报IllegalThreadStateException
      //我们需要重新创建一个线程的对象。
       MyThead myThead1 = new MyThead();
       myThead1.start();
       for (int i = 0; i <= 100; i++) {
               if (i % 2 == 0) {
                   System.out.println(Thread.currentThread().getName()+":"+i+"*********main()*********");
               }
           }
   }
    }

运行之后如下所示：

 

 示例三：

package com.hy;

/**
 * 练习：创建两个分线程，其中一个线程遍历100以内的偶数，另一个线程遍历100以内的奇数。
 */
public class ThreadDemo {
    public static void main(String[] args) {
        ThreadTest1 threadTest1 = new ThreadTest1();
        threadTest1.start();
        ThreadTest2 threadTest2 = new ThreadTest2();
        threadTest2.start();
    }
}

class  ThreadTest1 extends  Thread{
    public  void  run(){
        for (int i=0;i<100;i++){
            if(i%2==0){
                System.out.println(Thread.currentThread().getName()+":"+i);
            }
        }
    }
}

class ThreadTest2 extends Thread{
    public  void  run(){
        for (int i=0;i<100;i++){
            if(i%2!=0){
                System.out.println(Thread.currentThread().getName()+":"+i);
            }
        }
    }
}

 运行之后如下所示：

示例四：创建Thread类的匿名子类的方式

package com.hy;

/**
 * 练习：创建两个分线程，其中一个线程遍历100以内的偶数，另一个线程遍历100以内的奇数。
 */
public class ThreadDemo {
    public static void main(String[] args) {
        //创建Thread类的匿名子类的方式
      new Thread(){
          public  void  run(){
              for (int i=0;i<100;i++){
                  if(i%2==0){
                      System.out.println(Thread.currentThread().getName()+":"+i);
                  }
              }
          }
      }.start();



        new Thread(){
            public  void  run(){
                for (int i=0;i<100;i++){
                    if(i%2!=0){
                        System.out.println(Thread.currentThread().getName()+":"+i);
                    }
                }
            }
        }.start();
    }
}

class  ThreadTest1 extends  Thread{
    public  void  run(){
        for (int i=0;i<100;i++){
            if(i%2==0){
                System.out.println(Thread.currentThread().getName()+":"+i);
            }
        }
    }
}

class ThreadTest2 extends Thread{
    public  void  run(){
        for (int i=0;i<100;i++){
            if(i%2!=0){
                System.out.println(Thread.currentThread().getName()+":"+i);
            }
        }
    }
}

运行之后如下所示：

  

示例五：

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

    public static void main(String[] args) {
        //main线程，主线程
        //创建一个线程对象
        TestThread1 testThread1 = new TestThread1();
        //调用start（）方法开启线程
        testThread1.start();//两条线程是同时执行的。
        for (int i = 0; i < 20; i++) {
            System.out.println("我在学习多线程--"+i);
        }
    }
}

运行界面如下所示：

 调用run方法，两条线程先执行run方法，后执行run后面的方法。

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

    public static void main(String[] args) {
        //main线程，主线程
        //创建一个线程对象
        TestThread1 testThread1 = new TestThread1();
        //调用start（）方法开启线程
        testThread1.run();//两条线程是先执行run，后执行另一个线程。
        for (int i = 0; i < 20; i++) {
            System.out.println("我在学习多线程--"+i);
        }
    }
}

运行界面如下： 

实现Runnable接口：

定义MyRunnable类实现Runnable接口

实现run（）方法，编写线程执行体

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

推荐使用Runnable对象，因为java单继承的局限性

package com.rgf.DuoXian;
//创建线程方式2:实现Runnable接口，重写run方法，执行线程需要丢入runnable接口实现类，调用start方法
public class TestThread3 implements Runnable {
    @Override
    public void run() {
        //run方法线程体
        for (int i = 0; i < 20; i++) {
            System.out.println("我在看代码---"+i);
        }
    }

    public static void main(String[] args) {
       //创建Runnable接口的实现类对象
        TestThread3 testThread3 = new TestThread3();
        //创建线程对象，通过线程对象来开启我们的线程，代理
        Thread thread = new Thread(testThread3);
        //调用start（）方法开启线程
        thread.start();
      //new Thread(testThread3).start();以上两行代码可以合并成一行代码。
        for (int i = 0; i < 20; i++) {
            System.out.println("我在学习多线程--"+i);
        }
    }
}

运行界面如下所示：

示例二：

package com.ypl.exercise;

/**
 * 创建多线程的方式二：实现Runnable接口
 * 1.创建一个实现了Runnable接口的类
 * 2.实现类去实现Runnable中的抽象方法：run()
 * 3.创建实现类的对象
 * 4.将此对象作为参数传递到Thread类的构造器中，创建Thread类的对象
 * 5.通过Thread类的对象调用start()
 */
//1.创建一个实现了Runnable接口的类
class MThread implements Runnable{
//2.实现类去实现Runnable中的抽象方法：run()
    @Override
    public void run() {
        for (int i=0;i<100;i++){
            if(i%2==0){
                System.out.println(Thread.currentThread().getName()+":"+i);
            }
        }
    }
}
public class ThreadTest1 {
    public static void main(String[] args) {
        //3.创建实现类的对象
        MThread mThread = new MThread();
        //4.将此对象作为参数传递到Thread类的构造器中，创建Thread类的对象
        Thread t1 = new Thread(mThread);
        t1.setName("线程一");
        //5.通过Thread类的对象调用start():(1)启动线程（2）调用当前线程的run() -->调用了Runnable类型的target的run()
        /**
         *  public void run() {
         *         if (target != null) {
         *             target.run();
         *         }
         *     }
         *  private Runnable target;
         *
         */
         t1.start();

         //再启动一个线程：遍历100以内的偶数
        Thread t2 = new Thread(mThread);
        t2.setName("线程2");
        t2.start();
    }
}

 运行之后如下所示：

 Thread类和Runnable小结（两种方式的对比）

继承Thread类：

子类继承Thread类具备多线程能力

启动线程：子类对象.start()

不建议使用：避免面向对象单继承局限性

实现Runnable接口：

实现接口Runnable具有多线程能力

启动线程：传入目标对象+Thread对象.start()

推荐使用：避免单继承局限性，灵活方便，方便同一个对象被多个线程使用。

package com.ypl.exercise;

/**
 * 比较创建线程的两种方式：
 * 开发中：优先选择：实现Runnable接口的方式
 * 原因：1.实现的方式没有类的单继承性的局限性
 * 2.实现的方式更适合来处理多个线程有共享数据的情况
 * 联系：
 * public class Thread implements Runnable 
 * 相同点：两种方式都需要重写run(),将线程要执行的逻辑声明在run()中。
 */
public class ThreadCompare {
}

JDK5.0新增线程创建方式：

新增方式一：实现Callable接口：

与使用Runnable相比，Callable功能更强大些

相比run()方法，可以有返回值

方法可以抛出异常

支持泛型的返回值

需要借助FutureTask（Future,可以对具体Runnable、Callable任务的执行结果进行取消、查询是否完成、获取结果等）（FutureTask是Future接口的唯一的实现类）（FutureTask同时实现了Runnable,Future接口，他既可以作为Runnable被线程执行，又可以作为Future得到Callable的返回值）

类，比如获取返回结果

我们代码示例如下所示：

package com.ypl.exer;

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

/**
 * 创建线程的方式三：实现Callable接口，---JDK5.0新增
 *如何理解实现Callable接口的方式创建多线程比实现Runnable接口创建多线程方式强大？
 * 1.call()可以有返回值的。
 * 2.call()可以抛出异常，被外面的操作捕获，获取异常的信息
 * 3.Callable是支持泛型的
 */
//1.创建一个实现Callable的实现类
class NumThread implements Callable {
    //2.重写call方法，将此线程需要执行的操作声明在call()中
    @Override
    public Object call() throws Exception {
        int sum = 0;
        for (int i = 0; i <=100; i++) {
            if (i % 2 == 0) {
                System.out.println(i);
                sum += i;
            }
        }
        return sum;
    }
}

public class ThreadNew {
    public static void main(String[] args) {
        //3.创建Callable接口实现类的对象
        NumThread numThread = new NumThread();
        //4.将此Callable接口实现类的对象作为参数传递到FutureTask构造器中，创建FutureTask的对象
        FutureTask futureTask = new FutureTask(numThread);
        //5.将FutureTask的对象作为参数传递到Thread类的构造器中，创建Thread对象，并调用start()
        Thread thread = new Thread(futureTask);
        thread.start();
        try {
            //6.获取Callable中call方法的返回值
            //get()返回值即为FutureTask构造器参数Callable实现类重写的call（）的返回值。
            Object sum=futureTask.get();
            System.out.println("总和为："+sum);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
           e.printStackTrace();
        }

    }
}

运行之后如下所示：

 新增方式二：使用线程池

思路：提前创建好多个线程，放入线程池中，使用时直接获取，使用完放回池中，可以避免频繁创建销毁、实现重复利用。类似生活中的公共交通工具

好处：提高响应速度（减少了创建了新线程的时间）

降低资源消耗（重复利用线程池中线程，不需要每次都创建）

便于线程管理

corePoolSize:核心池的大小

maximumPoolSize:最大线程数

keepAliveTime:线程没有任务时最多保持多长时间后会终止

JDK5.0起提供了线程池相关API:ExecutorService和Executors

ExecutorService:真正的线程池接口。常见子类ThreadPoolExecutor

void execute(Runnable command):执行任务/命令，没有返回值，一般用来执行Runnable

<T> Future <T> submit(Callable<T> task):执行任务，有返回值，一般又来执行Callable

void shutdown():关闭连接池

Executors:工具类，线程池的工厂类，用于创建并返回不同类型的线程池

Executors:newCachedThreadPool():创建一个可根据需要创建新线程的线程池

Executors：newFixedThreadPool(n):创建一个可重用固定线程数的线程池

Executors：newSingleThreadExecutor():创建一个只有一个线程的线程池

Executors：newScheduledThreadPool(n):创建一个线程池，它可安排在给定延迟后运行命令或者定期的执行。

我们实现代码如下所示：

package com.ypl.exer;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.ThreadPoolExecutor;

/**
 * 创建线程的方式四：使用线程池
 * 好处：
 * 1.高响应速度（减少了创建了新线程的时间）
 *2.降低资源消耗（重复利用线程池中线程，不需要每次都创建）
 *3.便于线程管理
 * corePoolSize:核心池的大小
 * maximumPoolSize:最大线程数
 * keepAliveTime:线程没有任务时最多保持多长时间后会终止
 */

class  NumberThread implements Runnable{
    @Override
    public void run() {
        for(int i=0;i<=100;i++){
            if(i%2==0){
                System.out.println(Thread.currentThread().getName()+":"+i);
            }
        }
    }
}

class  NumberThread1 implements Runnable{
    @Override
    public void run() {
        for(int i=0;i<=100;i++){
            if(i%2!=0){
                System.out.println("奇数为："+Thread.currentThread().getName()+":"+i);
            }
        }
    }
}
public class ThreadPool {
    public static void main(String[] args) {
        //1.提供指定线程数量的线程池
        //Executors：newFixedThreadPool(n):创建一个可重用固定线程数的线程池
        ExecutorService service = Executors.newFixedThreadPool(10);
        ThreadPoolExecutor  service1=(ThreadPoolExecutor)service;
        //设置线程池的属性
        System.out.println(service.getClass());
        //service1就有很多属性，类当中的属性很多可以是变量，接口中进行设置很难实现
        service1.setCorePoolSize(15);

        //能提交
 /*       service.submit(Callable callable);//适合适用于Callable*/
        //能执行
        //2.执行指定的线程的操作，需要提供实现Runnable接口或Callable接口实现类的对象
        service.execute(new NumberThread());//适合适用于Runnable
        service.execute(new NumberThread1());
        //3.关闭连接池
        service.shutdown();
    }
}

运行之后如下所示：