Java学习之多线程详解

一、多线程的实现

1.继承Thread类

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

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

​ c.不建议使用：避免OOP单继承局限性

package com.tang;
/*
* 多线程学习的第一个demo
* */
public class Demoted01 extends Thread {
    public void run(){
//        run方法线程体
        for (int i = 0; i < 20; i++) {
            System.out.println("我在看代码---"+i);
        }
    }

    public static void main(String[] args) {
//        main线程，主线程

//        创建一个线程对象
        Demoted01 demoted01 = new Demoted01();
//        调用start() 方法开启线程
        demoted01.start();

        for (int j = 0; j < 30; j++) {
            System.out.println("我在学习多线程---"+j);
        }
    }
}

2.实现Runnable接口

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

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

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

实现步骤：

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

​ 2.在实现类中重写Runnable接口的run方法，设置线程任务。

​ 3.创建一个Runnable接口的实现类对象

​ 4.创建Thread类对象，构造方法中传递Runnable接口的实现类对象。

​ 5,。调用Thread类中的start方法，开启新的线程执行方法。

package com.tang;
/*
*1.定义MyRunnable类实现Runnable接口
*2.实现run方法,编写线程执行体
*3.创建线程对象，调用start()方法启动线程
*
*
* 推荐使用的创建线程的方式
* 实现runnable接口，重写run方法，=
* */
public class DemoRunnable 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接口的实现类对象
        DemoRunnable demoRunnable = new DemoRunnable();
//        创建线程对线，通过线程对象来开启我们的线程，代理
        new Thread(demoRunnable).start();

        for (int i = 0; i < 30; i++) {
            System.out.println("我在学习多线程---"+i);
        }
    }
}

---

//一份资源
startThread4 station = new StartThread4();

//多个代理
new Thread(station,"小明").start();
new Thread(station,"老师").start();
new Thread(station,"小红").start();

2.1实现Runnable接口创建多线程程序的好处：

​ 1.避免了单继承的局限性

​ 一个类只能继承一个类，类继承了Thread类就不能继承其他的类。

​ 实现了Runnable接口，还可以继承其他的类，实现其他的接口。

​ 2.增强了程序的扩展性，降低了程序的耦合性（解耦）

​ 实现Runnable接口的方式，把设置线程任务和开启新线程进行了分离（解耦）。

​ 实现类中，重写了run方法：用来设置线程任务

​ 创建Thread类对象，调用start方法：用来开启新线程。

二、匿名内部内实现线程的创建

1.匿名内部类作用：简化代码

​ 把子类继承父类，重写父类方法，创建子类对象合一步完成。

​ 把实现类接口，重写接口中的方法，创建实现类对象合一步完成。

​ 匿名内部类的最终产物：子类/实现类对象，而这个类没有名字。

2.格式：

new 父类/接口(){
    重复父类/接口中的方法
}

3.例子

package DemoInnerClass;

/*
* 匿名内部内创建Thread多线程
* */

public class DemoMain01 {
    public static void main(String[] args) {
        new Thread(){
            @Override
            public void run() {
                for (int i = 0; i < 20; i++) {
                    System.out.println("JAVA，你好"+i);
                }
            }
        }.start();
        test();
    }

    private static void test() {
        for (int i = 0; i < 30; i++) {
            System.out.println("HelloWorld"+i);
        }
    }

}

package DemoInnerClass;
/*
* 匿名内部类创建Runnable多线程
* */
public class DemoMain02 {
    public static void main(String[] args) {
        Runnable ra = new Runnable() {

            @Override
            public void run() {
                for (int i = 0; i < 20; i++) {
                    System.out.println("HelloWorld"+i);
                }
            }
        };
        new Thread(ra).start();

        test2();
    }

    private static void test2() {
        for (int i = 0; i < 20; i++) {
            System.out.println(Thread.currentThread().getName()+"--->"+i);
        }
    }
}

三、线程安全问题

3.1使用代码块解决线程安全

格式：

synchronized(锁对象){
    可能会出现线程安全问题的代码(访问了共享数据)
}

【注意】：

​ 1.通过代码块中的锁对象，可以使用任意的对象。

​ 2.但是必须保证多个线程使用的锁对象是同一个。

​ 3.锁对象作用：把同步代码块锁住，只让一个县城在同步代码块中执行。

实现类代码：

package LockObject;

public class RunnableImpl implements Runnable {
//    定义一个多线程的共享资源
    private int ticket = 100;
//定义一个锁对象
    Object o1 = new Object();
    @Override
    public void run() {
        while (true) {
            synchronized (o1){
                if (ticket > 0) {
//                sleep提高出现安全问题的概率
                    try {
                        Thread.sleep(10);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread().getName() + "--->正在售卖第" + ticket + "张票!");
                    ticket--;
            }
        }
    }
    }
}

3.2使用同步方法解决线程安全问题

使用步骤：

​ 1.把访问了共享数据的代码抽取出来，放到方法中。

​ 2.在方法上添加synchronized修饰符

格式：定义方法的格式：

修饰符 synchronized 返回值类型 方法名称(参数列表){
    可能会出现线程安全问题的代码(访问了共享数据的代码)
}

实现类代码：

package DemoMethod;

public class RunnableImpl implements Runnable {
//    定义一个多线程的共享资源
    private int ticket = 100;

    @Override
    public void run() {
        while (true) {
            run1();
        }
    }
    public synchronized void run1(){
        if (ticket > 0) {
//                sleep提高出现安全问题的概率
            try {
                Thread.sleep(10);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName() + "--->正在售卖第" + ticket + "张票!");
            ticket--;
        }
    }
}

3.3使用lock锁解决线程安全问题

java.until.concurrent.locks.lock接口

lock实现提供了比使用synchronized方法和语句可获得的更广泛的锁定操作。

lock接口中的方法：

​ void lock()获取锁

​ void unlock() 释放锁

java.until.concurrent.locks.ReentrantLock implements Lock接口

使用步骤：

​ 1.在成员位置创建一个ReentrantLock对象

​ 2.在可能会出现安全问题的代码前调用lock接口中的方法lock获取锁。

​ 3.在可能会出现安全问题的代码后调用lock接口中的方法unlock释放锁。

实现类的代码:

package DemoLock;

import java.util.concurrent.locks.ReentrantLock;

public class RunnableImpl implements Runnable {
//    定义一个多线程的共享资源
    private int ticket = 100;

//创建一个ReentrantLock对象
    ReentrantLock r1 = new ReentrantLock();
    @Override
    public void run() {
        while (true) {
            r1.lock();
            if (ticket > 0) {
//                sleep提高出现安全问题的概率
                try {
                    Thread.sleep(10);
                    System.out.println(Thread.currentThread().getName() + "--->正在售卖第" + ticket + "张票!");
                    ticket--;
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }finally {
                    r1.unlock();
                }

            }
        }
    }
}

调用方法的代码：

package DemoLock;

public class DemoMain {
    public static void main(String[] args) {
        RunnableImpl ra = new RunnableImpl();
        Thread mt1 = new Thread(ra);
        Thread mt2 = new Thread(ra);
        Thread mt3 = new Thread(ra);
        mt1.start();
        mt2.start();
        mt3.start();
    }
}

四、线程之间的通信

4.1等待唤醒案例

​ 创建一个顾客线程（消费者）：告知老板要的包子的种类和数量，调用wait方法，放弃cpu的执行，进入到WAITING状态（无线等待）

​ 创建一个老板线程（生产者）：花了5秒做包子，做好包子之后，调用notify方法，唤醒顾客吃包子。

【注意】：

​ 顾客和老板线程必须使用同步代码块包裹起来，保证等待和唤醒只能有一个在执行。

​ 同步使用的锁对象必须保证唯一。

​ 只有锁对象才能调用wait和notify方法

Object类中的方法：

​ void wait()

​ 在其他线程调用此对象的notify方法或notifyALL方法，导致当前线程等待。

​ void notify()

​ 唤醒在此对象监视器上等待的单个线程。

​ 会继续执行wait方法之后的代码。

4.2计时等待

​ 1.使用sleep(long m)方法，在毫秒值结束之后，线程睡醒进入到Runnable/Blocked状态。

​ 2.使用wait(long m)方法，wait方法如果在毫秒值结束之后，还没有被notify唤醒，就会自动醒来，线程睡醒进入到Runnable/Blocked状态。

唤醒的方法：

​ void notify() 唤醒在此对象监视器上等待的单个线程。

​ void notifyALL() 唤醒在此对象监视器上等待的所有线程。

五、线程池

5.1线程池：JDK1.5以后提供的：

​ java.util.concurrent.Executors:线程池的工厂类，用来生成线程池。

5.2Executors类中的静态方法：

​ static ExecutorService newFixedThreadPool(int nThreads) 创建一个指定线程数量的线程池。

​ 参数：

​ int nThreads:创建线程池中包含的线程数量。

​ 返回值：

​ ExecutorService接口：返回的是ExecutorService接口的实现类对象，我们可以使用ExecutorService接口接收(面向接口编程)

5.3java.util.concurrent.ExecutorService:线程池接口

​ 用来从线程池中获取线程，调用start方法，执行线程任务。

​ submit(Runnable task) 提交一个Runnable任务用于执行。

​ 关闭/销毁线程池的方法

​ void shutdown()

5.4线程池的使用步骤：

​ 1.使用线程池的工厂类Executors里面提供的静态方法newFixedThreadPool生产一个指定线程数量的线程池

​ 2.创建一个类，实现Runnable接口，重写run方法，设置线程任务

​ 3.调用ExecutorService中的方法submit，传递线程任务(实现类),开启线程，执行run方法

​ 4.调用ExecutorService中的方法shutdown销毁线程池（不建议执行）

六、Lambda表达式

6.1标准格式：

​ 由三部分组成：

​ a.一些参数

​ b.一个箭头

​ c.一段代码

​ 格式：

​ (参数列表) -> {一些重写方法的代码};

​ 解释说明格式：

​ ():接口中抽象方法的参数列表，没有参数，就空着；有参数就写出参数，多个参数使用逗号分隔。

​ ->:传递的意思，把参数传递给方法体{}

​ {}：重写接口的抽象方法的方法体

6.2 Lambda的使用前提

​ 1.使用Lambda必须具有接口，且要求接口中有且仅有一个抽象方法。

​ 无论是JDK内置的Runnable、Comparator接口还是自定义的接口，只有当接口中的抽象方法存在且唯一时，才可以使用Lambda。

​ 2.使用Lambda必须具有上下文推断。

​ 也就是方法的参数或局部变量类型必须为Lambda对应的借口了偶像，才能使用Lambda作为该接口的实例。

备注：有且仅有一个抽象方法的接口，称为“函数式接口”。