Java多线程

多线程

基本概念：程序、进程、线程

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

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

->程序是静态的，进程的动态的

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

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

->若一个进程同一时间并行执行多个线程，就是支持多线程的

->线程作为调度和执行的单位，每个线程拥有独立的运行栈和程序计数器(pc)

->一个进程中的多个线程共享相同的内存单元/内存地址空间→它们从同一堆3中分配对象，可以访问相同的变量和对象。这就使得线程间通信更便捷、高效。但多个线程操作共享的系统资源可能会带来安全的隐患

并行与并发

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

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

多线程的优点

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

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

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

何时需要多线程

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

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

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

多线程的创建

方式一

1.创建一个继承于Thread类的子类

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

3.创建Thread类的子类的对象

4.通关此对象调用start()方法

start()作用:1.启动当前线程 2.调用当前线程的run()方法

示例代码

class MyThead extends Thread{
    //重写run方法
    @Override
    public void run() {
        for (int i=0;i<100;i++){
            if (i%2==0){
                System.out.println(i);
            }
        }
    }
}
​
public class Demo {
    public static void main(String[] args) {
        //创建Thread类的子类对象
        MyThead mt=new MyThead();
​
        //通过此对象调用start方法
        mt.start();
    }
}
​
//***********************************************//
​
//创建Therad类的子类另一种方式
public static void main(String[] args) {
        //创建Thread类的匿名子类的方式
        new Thread(){
            @Override
            public void run() {
                for (int i=0;i<100;i++){
                    if (i%2==0){
                        System.out.println(i);
                    }
                }
            }
        }.start();

注意：1.我们不能直接调用run()的方式来启动线程

2.一个对象只能调用一次start方法，否则会报IllegalThreadStateException异常，如果需要再次调用，需要重新创建一个线程对象去调用start方法

线程的常用方法

start():启动当前线程、调用当前线程的run()
    
run():通常需要重写Thread类中的此方法，将创建的线程要执行的操作声明在此方法中
    
currentThread():静态方法，返回当前代码执行的线程
    
getName():获取当前线程的名字
​
setName():设置当前线程的名字
    
yield():释放当前cpu的执行权
    
join():在线程a中调用线程b的join(),此时线程b进入阻塞状态,直到线程b完全执行完之后,线程a才结束阻塞状态
    
sleep(long millitime):让当前线程“睡眠”指定的millitime毫秒数,在指定的时间内,线程是阻塞状态
    
isAlive():判断当前线程是否存活

线程的调度

Java的调度方法

同优先级线程组成先进先出队列（先到先服务）

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

线程的优先级等级

MAX_PRIORITY: 10

MIN_PRIORITY: 1

NORM_PRIORITY: 5

涉及的方法

getPriority():返回线程优先值
    
setPriority(int p):改变线程的优先级

说明

线程创建时继承父线程的优先级

低优先级只是获得调度的概率低，并非一定是在高优先级之后才被调用

方式二

实现Runnable接口

1.创建一个实现了Runnable接口的类

2.实现类去实现Runnable中的抽象方法：run()

3.创建实现类的对象

4.将此对象作为参数传递到Thread类的构造器中，创建Thread类的对象

5.通过Thread类的对象调用start()

示例代码

//例:遍历100以内的所有偶数
​
//创建一个实现Runnable接口的类
class MyThead implements Runnable{
​
    //实现类去实现Runnable的抽象方法run()
    @Override
    public void run() {
        for (int i=0;i<100;i++){
            if (i%2==0){
                System.out.println(i);
            }
        }
    }
}
​
public class Demo {
    public static void main(String[] args) {
        //创建实现类的对象
        MyThead mt=new MyThead();
        //将实现类的对象作为参数传递到Thread类的构造器中，创建Thread类的对象
        Thread t = new Thread(mt);
        //通过Thread类的对象调用start()
        t.start();
    }
}

比较创建线程的两种方式

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

原因：1.实现的方式没有类的单继承的局限性

2.实现的方式更适合来处理多个线程有共享数据的情况

联系：Thread类本身也实现了Runnable接口

相同点：两种方式都需要重写run()，将线程要执行的逻辑声明在run()中

线程的生命周期

JDK中用Thread.State类定义了线程的几种状态

要想实现多线程，必须在主线程中创建新的线程对象。Java语言使用Thread类及其子类的对象来表示线程，在它一个完整的生命周期中通常要经历如下的五种状态：

新建：当一个Thread类或其子类的对象被声明或创建时，新生的线程对象处于新建状态

就绪：处于新建状态的线程被strat()后，将进入线程队列等待CPU时间片，此时它已经具备了运行的条件，只是没分配到CPU资源

运行：当就绪的线程被调度并获得CPU资源时，便进入运行状态，run()方法定义了线程的操作和功能

阻塞：在某种特殊情况下，被人为挂起或执行输入输出操作，让出CPU并临时中止自己的执行，进入阻塞状态

死亡：线程完成了它的全部工作或线程被提前强制性的中止或出现异常导致结束

 

线程的同步

在Java中，我们通过同步机制，来解决线程安全问题

方式一：同步代码块

synchronized(同步监视器){
    //需要被同步的代码
}

说明：操作共享数据的代码，即为需要被同步的代码 共享数据：多个线程共同操作的变量 同步监视器：俗称：锁,然后一个类的对象都可以充当锁

要求：多个线程必须要共用一把锁。

示例代码

//例:三个窗口各自售票,不能重复、错票
​
//创建一个实现Runnable接口的类
class MyThead implements Runnable{
    private int ticket=100;
    Object o=new Object();//可以使用this指代当前对象,不用创建一个对象
    //实现类去实现Runnable的抽象方法run()
    @Override
    public void run() {
        while (true){
            synchronized (o){
                if (ticket>0){
                    System.out.println(Thread.currentThread().getName()+":"+ticket);
                    ticket--;
                }else {
                    break;
                }
            }
        }
    }
}
​
public class Demo {
    public static void main(String[] args) {
        //创建实现类的对象
        MyThead mt=new MyThead();
        //将实现类的对象作为参数传递到Thread类的构造器中，创建Thread类的对象
        Thread t1 = new Thread(mt);
        Thread t2 = new Thread(mt);
        Thread t3 = new Thread(mt);
​
        t1.setName("窗口一");
        t2.setName("窗口二");
        t3.setName("窗口三");
        //通过Thread类的对象调用start()
        t1.start();
        t2.start();
        t3.start();
    }
}
​
//上述代码是对实现Runnable接口进行处理
//要对继承Thread类进行处理，需要new的对象需要使用同一把锁，也就是创建对象时需要static修饰

方式二：同步方法

如果操作共享数据的代码完整的声明在一个方法中，就可以将此方法声明为同步的

示例代码

//例:三个窗口各自售票,不能重复、错票
​
//创建一个实现Runnable接口的类
class MyThead implements Runnable{
    private int ticket=100;
    //实现类去实现Runnable的抽象方法run()
    @Override
    public void run() {
        while (true){
            //调用方法
            sell();
            if (ticket==0){
                break;
            }
        }
    }
​
    //操作共享数据的代码
    private synchronized void sell(){
        if (ticket>0){
            System.out.println(Thread.currentThread().getName()+":"+ticket);
            ticket--;
        }
    }
}
​
public class Demo {
    public static void main(String[] args) {
        //创建实现类的对象
        MyThead mt=new MyThead();
        //将实现类的对象作为参数传递到Thread类的构造器中，创建Thread类的对象
        Thread t1 = new Thread(mt);
        Thread t2 = new Thread(mt);
        Thread t3 = new Thread(mt);
​
        t1.setName("窗口一");
        t2.setName("窗口二");
        t3.setName("窗口三");
        //通过Thread类的对象调用start()
        t1.start();
        t2.start();
        t3.start();
    }
}

注意：

1.同步方法任然涉及到同步监视器，只是不需要我们显示声明

2.非静态的同步方法，同步监视器是：this

静态的同步方法，同步监视器是：当前类本身

线程的死锁问题

死锁：

不同的线程分别占用对方需要的同步资源部放弃，都在等待对方放弃自己需要的同步资源，就形成了线程的死锁

出现死锁后，不会出现异常，不会出现提示，只是所有线程都处于阻塞状态，无法继续

解决方法：

1.专门的算法、原则

2.尽量减少同步资源的定义

3.尽量避免嵌套同步

Lock(锁)

从JDK 5.0开始，Java提供了更强大的线程同步机制——通过显式定义同步锁对象来实现同步。同步锁使用Lock对象充当

java.util.concurrent.locks.Lock接口是控制多个线程队共享资源进行访问的工具。锁提供了对共享资源的独占访问，每次只能有一个线程的Lock对象加锁，线程开始访问共享资源之前应先获得Lock对象

ReentrantLock类实现了Lock，它拥有与synchronized相同的并发性和内存语义，在实现线程安全的控制中，比较常用的是ReentrantLock，可以显式加锁、释放锁

示例代码

import java.util.concurrent.locks.ReentrantLock;
​
//三个窗口卖票
class window implements Runnable{
​
    //车票总数
    private int ticket=100;
    //1.lock锁
    private ReentrantLock lock=new ReentrantLock();
    //重写run方法
    @Override
    public void run() {
        while (true){
            try {
                //2.调用lock方法
                lock.lock();
                if (ticket>0){
                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread().getName()+":"+ticket);
                    ticket--;
                }else{
                    break;
                }
            }finally {
                //3.释放锁:调用unlock方法
                lock.unlock();
            }
        }
    }
}
​
public class Demo {
    public static void main(String[] args) {
        window w=new window();
​
        Thread t1=new Thread(w);
        Thread t2=new Thread(w);
        Thread t3=new Thread(w);
​
        t1.setName("窗口1");
        t2.setName("窗口2");
        t3.setName("窗口3");
​
        t1.start();
        t2.start();
        t3.start();
    }
}

synchronized和Lock的异同？

相同：二者都可以解决线程安全问题

不同：synchronized机制在执行完相应的同步代码后，自动释放同步监视器。Lock需要手动的启动同步（lock()），同时结束同步也需要手动的实现（unlock()）

Lock只有代码块锁，synchronized有代码块锁和方法锁

使用Lock锁，JVM将花费较少的时间来调度线程，性能更好。并且具有更好的扩展性

优先使用顺序

Lock--->同步代码块（已经进入的方法体，分配了相应资源）--->同步方法（在方法体之外）

线程的通信

示例代码

//例：使用两个线程打印1到100，两个线程交替打印
​
class Number implements Runnable{
    private int number=1;
    @Override
    public void run() {
        while (true){
            synchronized (this){
                //唤醒操作
                notify();
                if (number<=100){
                    System.out.println(Thread.currentThread().getName()+":"+number);
                    number++;
                    try {
                        //调用wait()方法使其进入阻塞状态
                        wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }else {
                    break;
                }
            }
​
        }
    }
}
​
public class Demo {
    public static void main(String[] args) {
        Number n=new Number();
​
        Thread t1=new Thread(n);
        Thread t2=new Thread(n);
​
        t1.setName("线程一");
        t2.setName("线程二");
​
        t1.start();
        t2.start();
    }
}

涉及到的三个方法

wait()：执行此方法，当前线程进入阻塞状态，并释放同步监视器

notify()：执行此方法，就会唤醒被wait的一个线程。如果有多个线程被wait，就唤醒优先级高的

notifyAll()：执行此方法，会唤醒所有被wait的线程

注意：

1.wait()、notify()、notifyAll()三个方法必须使用在同步代码块或同步方法中

2.三个方法的调用者必须是同步代码块或同步方法的同步监视器

3.三个方法定义在Object类当中

sleep()和wait()的异同

相同点：一旦执行方法，都可以使当前线程进入阻塞状态

不同点：1.两个方法声明的位置不同：Thread类中声明sleep()，Object类中声明wait()

2.调用的要求不同；sleep()可以在任何需要的场景下调用，wait()必须使用在同步代码块或同步方法中

3.sleep()不会释放同步监视器，wait()会释放

JDK5.0新增线程创建方式

方式一：实现Callable接口

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

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

●方法可以抛出异常

●支持泛型的返回值

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

Future接口

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

●FutureTask是Future接口的唯一实现类

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

示例代码

//1.创建一个实现Callable的实现类
class NumThrad 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 Demo {
    public static void main(String[] args) {
        //3.创建Callable接口的实现类对象
        NumThrad num = new NumThrad();
​
       //4.将Callable接口的实现类对象作为参数传递到FutureTask构造器中，创建FutureTask的对象
        FutureTask ft = new FutureTask(num);
​
        //将FutureTask的对象作为参数传递到Thread类的构造器中，创建Thread对象，并调用start()
        new Thread(ft).start();
        try {
            //get()方法返回值即为FutureTask构造器参数Callable实现类重写的call()的返回值
            Object o = ft.get();
            System.out.println("总和为"+o);
        } catch (InterruptedException | ExecutionException e) {
            e.printStackTrace();
        }
    }
}

​

方式二：使用线程池

●背景：经常创建和销毁、使用量特别大的资源，比如并发情况下的线程，对性能影响很大

●思路：提前创建好多个线程，放入线程池中，使用时直接获取，使用完放回池中。可以避免频繁创建销毁、实现重复利用。

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

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

3.便于线程管理

corePoolSize: 核心池的大小

maximumPoolSize： 最大线程数

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

线程池的相关API: ExecutorService和Executors

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

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

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

->void shutdown()：关闭连接池

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

->Executors.newCashedThreadPool()：创建一个可根据需要创建新线程的线程池

->Executor.newFixedThreadPool(n)：创建一个可重用固定线程数的线程池

->Excutors.newSingleThreadExcutor()：创建一个只有一个线程的线程池

->Excutor.newScheduledThreadPool(n)：创建一个线程池，它可安排在给定延迟后运行命令或者定期执行

示例代码

//例：两个线程输出100以内偶数与奇数
class NumThrad implements Runnable{
​
    //实现run方法
    @Override
    public void run() {
        for (int i=0;i<100;i++){
            if (i%2==0){
                System.out.println(Thread.currentThread().getName()+":"+i);
            }
        }
    }
}
​
class NumThrad1 implements Callable {
    //实现call方法
    @Override
    public Object call() throws Exception {
        //总和
        int sum=0;
        for (int i=0;i<100;i++){
            if (i%2!=0){
                System.out.println(Thread.currentThread().getName()+":"+i);
                sum+=i;
            }
        }
        return sum;
    }
}
​
public class Demo {
    public static void main(String[] args) {
        //1.调用工具类创建指定线程数量线程池
        ExecutorService service = Executors.newFixedThreadPool(10);
        //2.执行指定线程的操作，需要提供实现Runnable接口或Callable接口实现类的对象
        service.execute(new NumThrad());//适用于Runnable
        service.submit(new FutureTask(new NumThrad1())); //适用于Callable
​
        //3.关闭连接池
        service.shutdown();
    }
}