Java多线程（一）

目录

一、基本概念

程序、进程、线程

单核CPU和多核CPU

并行与并发

使用多线程的优点

二、线程的创建与使用

线程的创建和启动

Thread类

Thread类的特性

Thread类的构造器

API中创建线程的两种方式

创建线程方式一：继承Thread类

创建继承Thread类线程方式练习

 创建线程方式二：实现Runnable接口

创建实现Runnable接口线程方式练习

 比较创建线程的继承方式和实现Runnable接口方式

继承方式和实现Runnable接口方式的联系与区别

JDK5.0新增线程创建方式

创建线程方式三：实现Callable接口

实现Callable接口创建线程方式的练习

 如何理解实现Callable接口创建多线程的方式比实现Runnable接口创建多线程的方式强大？

创建线程方式四：使用线程池

使用线程池创建多线程方式练习

---

一、基本概念

程序、进程、线程

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

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

说明：

1、程序是静态的，进程是动态的。

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

线程：进程可进一步细化为线程，是一个程序内部的一条执行路径。

• 若一个进程同一时间并行执行多个线程，就是支持多线程的
• 线程作为调度和执行的单位，每个线程拥有独立的运行栈和程序计数器（pc）,线程切换的开销小
• 一个进程中的多个线程共享相同的内存单元/内存地址空间-->它们从同一堆中分配对象，可以访问相同的变量和对象。这就使得线程更加简便、高效。但多个线程操作共享的系统资源可能会带来线程安全问题

单核CPU和多核CPU

单核CPU，其实是一种假的多线程，因为在一个时间单元内，也只能执行一个线程的任务。但是因为CPU时间单元特别短，因此感觉不出来。

如果是多核的话，才能更好的发挥多线程的效率。（现在的服务器都是多核的）

一个Java应用程序java.exe，其实至少有三个线程：main()主线程，gc() 垃圾回收线程，异常处理线程。当然如果发生异常，会影响主线程。

并行与并发

并行：多个CPU同时执行多个任务。比如：多个人同时做不同的事。

并发：一个CPU(采用时间片)同时执行多个任务。比如：秒杀、多个人做同一件事。

使用多线程的优点

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

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

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

二、线程的创建与使用

线程的创建和启动

Java语言的JVM允许多个线程同时运行，它通过java.lang.Thread类来体现

Thread类

Thread类的特性

1.每个线程都是通过某个特定的Thread对象的run()来完成的，经常把run()的主体称为线程体

2.通过该线程对象的start()来启动这个线程，而非直接调用run()

Thread类的构造器

• Thread()：创建新的Thread对象
• Thread(String threadname)：创建线程并指定线程实例名
• Thread(Runnable target)：指定创建线程的目标对象，它实现了Runnable接口中的run方法
• Thread(Runnable target, String name)：创建新的Thread对象

API中创建线程的两种方式

JDK1.5之前创建新执行的线程有两种方式：

• 继承Thread类
• 实现Runnable接口的方式

创建线程方式一：继承Thread类

创建线程步骤：

1）定义子类继承于Thread类

2）子类中重写Thread类中的run()方法------>将执行线程的操作声明在run()中

3）创建Thread类的子类对象

4）通过此对象调用start()方法

注意点：

1、如果自己手动调用run()方法，那么就只是普通方法，没有启动多线程模式。

2、run()方法由JVM调用，什么时候调用，执行的过程控制都有操作系统的CPU 调度决定。

3、想要启动多线程，必须调用start()方法。

4、一个线程对象只能调用一次start()方法启动，如果重复调用了，则将抛出异常：“IllegalThreadStateException”。

5、如果想要在创建一个线程，应重新创建一个线程对象

创建继承Thread类线程方式练习

创建一个分线程，打印输出1-20以内偶数；主线程中输出1-20以内奇数

public class ThreadTest1 {
    public static void main(String[] args) {
//        3、创建Tread类的子类对象
        myThread p1=new myThread();
//        4、通过此对象调用start():①启动当前线程②调用当前线程的run()方法
        p1.start();
        //如下操作依旧在main线程中操作
        for(int i=0;i<=20;i++){
            if(i%2!=0){
                System.out.println(i+"'*******main()*******");
            }
        }
    }
}
 
//创建Thread类的子类对象
 
//1、继承于Thread子类
class myThread extends Thread {
    //2、重写Thread类中的run()方法
    public void run(){
        for(int i=0;i<20;i++){
            if(i%2==0){
                System.out.println(i);
            }
        }
    }
    
 }

 运行结果如下：

 创建线程方式二：实现Runnable接口

创建线程步骤：

1）定义实现类实现Runnable接口

2）子类中重写Runnable接口中的抽象方法：run()-------->将线程执行的操作声明在run()中

3）创建实现类的对象

4）将实现类的对象作为参数传递到Thread类的构造器中，并创建Thread类对象

5）通过Thread类的对象调用start()方法

创建实现Runnable接口线程方式练习

创建一个分线程，打印输出1-20以内偶数；主线程中输出1-20以内奇数

//1、创建一个实现了Runnable接口的类
class MThread implements Runnable{
   //2、实现类的Runnable接口的抽象方法：run()
    @Override
    public void run() {
        for(int i=0;i<=20;i++){
            if (i%2==0){
                System.out.println(i);
            }
 
        }
    }
}
 
public class ThreadTest2 {
    public static void main(String[] args) {
        //3、创建实现类的对象
        MThread mThread=new MThread();
        //4、将此对象作为参数传递到Thread类的构造其中，创建Thread类的对象
        //5、通过Thread类的对象调用start()方法:①启动线程 ②调用当前线程的run()-->调用了Runnable类的target的run()
        new Thread(mThread).start();
        //主线程
        for(int i=0;i<=20;i++){
            if (i%2!=0){
                System.out.println(i+"************main()***********");
            }
 
        }
 
    }
}

运行结果为：

 比较创建线程的继承方式和实现Runnable接口方式

开发中优先选择实现Runnable接口的方式

实现Runnable接口方式的好处：

1、实现Runnable接口方式的方式没有类的单继承性的约束

2、多个线程可以共享同一个接口实现类的对象，非常适合多个相同线程来处理同一份资源。

继承方式和实现Runnable接口方式的联系与区别

区别：

• 继承Thread类：线程代码存放在Thread子类的run()中
• 实现Runnable：线程代码存放在接口的子类的run()中

联系：

• Thread类本身也实现了Runnable接口
• 两种方式都重写了run()，将线程要执行的操作声明在run()中

JDK5.0新增线程创建方式

创建线程方式三：实现Callable接口

创建线程步骤：

1）创建一个Callable接口的实现类

2）重写Callable接口的抽象方法：call()------->将此线程操作声明在call()中（该方法有返回值）

3）创建Callable接口的实现类的对象

4）将此Callable接口的实现类的对象作为参数传递到FutureTask类的构造其中，并创建FutureTask类的对象

5）将FutureTask类的对象作为参数传递到Thread类的构造器中，并创建Thread类的对象

6）调用创建好的Thread类的对象的start()方法

7）可以获取call()的返回值（按需选择）

实现Callable接口创建线程方式的练习

创建一个线程打印1-20以内偶数，并求和，返回求和值

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;
 
public class ThreadNew1 {
    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类对象
        Thread thread = new Thread(futureTask);
//        并调用该类对象的start()
        thread.start();
        try {
            //get()返回值即为FutureTask构造器参数Callable实现类重写的call()的返回值
            Object sum = futureTask.get();
            System.out.println("总和为："+sum);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        } catch (ExecutionException e) {
            throw new RuntimeException(e);
        }
    }
}
 
// 1、创建一个实现Callable接口的实现类
class NumThread implements Callable{
//    2、实现call()，将此线程需要执行的操作声明在call()中；call()可以有返回值
    @Override
    public Object call() throws Exception {
        int sum=0;
        for(int i=1;i<=20;i++){
            if(i%2==0){
                System.out.println(i);
                sum+=i;
            }
        }
        return sum;//存在自动装箱
    }
}

运行结果如下：

 如何理解实现Callable接口创建多线程的方式比实现Runnable接口创建多线程的方式强大？

1）相比run()方法，call()方法有返回值

2）call()方法可以抛出异常

3）支持泛型的返回值

4）需要借助FutureTask类，比如获取返回结果

Future接口：

可以对具体Runnable、Callable任务的执行结果进行取消、查询是 否完成、获取结果等。

 FutrueTask是Futrue接口的唯一的实现类

 FutureTask 同时实现了Runnable, Future接口。它既可以作为 Runnable被线程执行，又可以作为Future得到Callable的返回值

创建线程方式四：使用线程池

创建线程步骤：

1）创建一个指定数量的线程池

2）执行指定的线程操作。需要提供实现Runnable接口或Callable接口实现类的对象

3）关闭线程池

线程池相关API：

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

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

• void execute(Runnable command) ：执行任务/命令，没有返回值，一般用来执行 Runnable
•  Future submit(Callable task)：执行任务，有返回值，一般又来执行 Callable
•  void shutdown() ：关闭连接池

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

• Executors.newCachedThreadPool()：创建一个可根据需要创建新线程的线程池
• Executors.newFixedThreadPool(n); 创建一个可重用固定线程数的线程池
•  Executors.newSingleThreadExecutor() ：创建一个只有一个线程的线程池
• Executors.newScheduledThreadPool(n)：创建一个线程池，它可安排在给定延迟后运 行命令或者定期地执行。

使用线程池创建多线程方式练习

使用线程池创建线程，一个线程打印输出1-20以内偶数，一个线程打印输出1-20以内奇数

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
 
public class ThreadNew2 {
    public static void main(String[] args) {
//        1、提供指定线程数量的线程池
        ExecutorService service = Executors.newFixedThreadPool(10);
 
//        2、执行指定的线程的操作。需要提供实现Runnable接口或Callable接口实现类的对象
        service.execute(new NumberThread());//适用于Runnable
 
        Future future = service.submit(new NumberThread1());//适用于Callable接口
//        3、关闭连接池
        service.shutdown();
    }
}
class NumberThread implements Runnable{
 
    @Override
    public void run() {
        for (int i = 0; i <=20; i++) {
            if(i%2==0){
                System.out.println(Thread.currentThread().getName()+"："+i);
            }
        }
    }
}
class NumberThread1 implements Callable{
    @Override
    public Object call() throws Exception {
        for (int i = 0; i <=20; i++) {
            if(i%2!=0){
                System.out.println(Thread.currentThread().getName()+"："+i);
            }
        }
        return null;
    }
}

运行结果：