Java之多线程

程序员文章站 2023-12-23 13:11:28

...

入谷第十天——多线程

线程

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

进程（process）：进程是程序的一次执行过程，或是正在运行中的程序。是一个动态的过程：他有自身的产生，消亡。进程作为资源分配的单位，系统会自动为每一个进程分配资源

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

若干个进程同一时间并行执行多个线程，就是多线程
现场作为调度和执行的单位，每个线程拥有独里的运行栈，程序计数器，线程切换的开销小
一个进程中的多个线程共享（堆，和方法区）相同的内存单元、内存地址空间-》他们从统一堆中分配对象，可以访问相同的变量和对象，这就是的线程之间的通信更简便，搞笑，但多个线程操作的系统资源可能就会带来安全隐患

单核CPU和多核CPU的理解

单核CPU，其实是一种假的多线程，因为在一个时间单元内，也只能执行一个线程

的任务。例如：虽然有多车道，但是收费站只有一个工作人员在收费，只有收了费
才能通过，那么CPU就好比收费人员。如果有某个人不想交钱，那么收费人员可以
把他“挂起”（晾着他，等他想通了，准备好了钱，再去收费）。但是因为CPU时
间单元特别短，因此感觉不出来。
如果是多核的话，才能更好的发挥多线程的效率。（现在的服务器都是多核的）
一个Java应用程序java.exe，其实至少有三个线程：main()主线程，gc()

垃圾回收线程，异常处理线程。当然如果发生异常，会影响主线程。
 并行与并发
并行：多个CPU同时执行多个任务。比如：多个人同时做不同的事。
并发：一个CPU(采用时间片)同时执行多个任务。比如：秒杀、多个人做同一件事。

使用多线程的优点背景：

以单核CPU为例，只使用单个线程先后完成多个任务（调用多个方法），肯定比用多个线程来完成用的时间更短，为何仍需多线程呢？

多线程程序的优点：

提高应用程序的响应。对图形化界面更有意义，可增强用户体验。
提高计算机系统CPU的利用率3. 改善程序结构。将既长又复杂的进程分为多个线程，独立运行，利于理解和

何时需要多线程

程序需要同时执行两个或多个任务。
程序需要实现一些需要等待的任务时，如用户输入、文件读写操作、网络操作、搜索等。
需要一些后台运行的程序

线程的分类

Java中的线程分为两类：一种是守护线程，一种是用户线程。

它们在几乎每个方面都是相同的，唯一的区别是判断JVM何时离开。
守护线程是用来服务用户线程的，通过在start()方法前调用thread.setDaemon(true)可以把一个用户线程变成一个守护线程。
Java垃圾回收就是一个典型的守护线程。
若JVM中都是守护线程，当前JVM将退出。
形象理解：兔死狗烹，鸟尽弓藏

线程的创建和使用

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

java中线程分类：守护线程，用户线程

线程的调度

调度策略：

时间片式
抢占式

java调度方法

通优先级的线程先进先出队列（先到先服务），使用时间片策略
对高优先级，优先调度的抢占式策略

方式一：继承Thread类

创建一个类，继承Thread
重写thread类的run（）方法
创建thread类的子类的对象
通过此类对象调用star（）作用1：启动当前线程 2：调用当前线程的run

注意

不能通过对象.run的方式创建一个线程，
不可以让已经start的线程再次执行start（）,需要重新new一个对象去开启另一个线程

示例代码

public class ThreadTest {
    public static void main(String[] args) {
        //创建Mythread对象
        MyThread myThread = new MyThread();
        //启动一个新的线程
        myThread.start();
//        myThread.run();//仍在主线程中运行
        //该循环仍在n主线程中执行
        for (int i = 0; i < 100; i++) {
            if (i % 2 != 0) {
                System.out.println(i + "main____");
            }
        }
        myThread.start();//再次开启线程会报错，

            System.out.println("hello");
    }
}

class MyThread extends Thread{
    //重写thread中的run方法，run方法不在主线程中执行
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            if (i % 2 == 0) {
                System.out.println(Thread.currentThread().getName()+":"+i);
            }

        }
    }
}

注意
1.不能通过对象.run的方式创建一个线程，
2不可以让已经start的线程再次执行start（）,需要重新new一个对象去开启另一个线程

Thread中的常用方法

start（）启动当前线程，调用当前线程的run（）
run（）；通常需要重写Thread当中run（）方法，将创建的线程需要在多线程中执行的操作声明在该方法中
currentThread（）：静态方法
getname（）:获取线程的名称
setname（）：给线程命名
yield():释放当前cpu的执行权，但是有可能下一次有分配到了执行权
j oin();在此处加入一个线程,等加入的线程执行完毕后在执行原来的线程：在线程A中调用B线程的jion（）方法，那么线程A进入阻塞状态，等到线程B执行完毕之后，线程A结束阻塞状态，再次等待cpu分配内存
stop()：已过时：当调用此方法时，强制停止线程
sheep（long milltimes）：让当前线程睡眠指定的毫秒数，之后在等着cpu分配资源（当前线程是阻塞状态）
isalive（）：判断当前线程是否存活

线程的优先级等级

MAX_PRIORITY：10
MIN _PRIORITY：1
NORM_PRIORITY：5

 涉及的方法

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

 说明

线程创建时继承父线程的优先级
低优先级只是获得调度的概率低，并非一定是在高优先级线程之后才被调用

练习1

例子：设计三个窗口买票，总票数为100张

public class WindowsTest {
    public static void main(String[] args) {
        Windows w1 = new Windows();
        Windows w2 = new Windows();
        Windows w3 = new Windows();
        w1.setName("窗口一");
        w2.setName("窗口二");
        w3.setName("窗口三");
        w1.start();
        w2.start();
        w3.start();
    }
}

class Windows extends Thread{
    private static int tickets = 100;//必须用static修饰
    static int total = 0;
    int sun = 0;
    @Override
    public void run() {
        while (true){
            if (tickets > 0){
                tickets--;
                System.out.println(Thread.currentThread().getName()+":"+"卖出一张票"+"票号为：" +tickets);
                total++;
                sun++;
            }else if(tickets == 0){
                System.out.println("一共卖出票"+total+"张");
                System.out.println(Thread.currentThread().getName()+"一共卖出票"+sun+"张");

                break;
            }
        }
    }
}

创建多线程的方式二，实现Runnable接口

创建一个类实现Runnable接口
实现类趋势线Runnable中的抽象方法
创建实现类对象
将此对象作为参数传递到Thread类的构造器中，创建Thread类的对象
通过Thread类的对象调用start（）方法

示例代码

public class TheradTest1 {
    public static void main(String[] args) {
        //创建一个实现类对象
        MTherad m = new MTherad();
        //将此对象作为参数传递给Thread类的构造器
        Thread thread = new Thread(m);
        thread.setName("线程一");
        //通过Thread对象调用start方法：1启动线程2.调用当前线程run（）--》调用了Runnable类型的target的run方法，就是我们写的
        thread.start();

        //在启动一个线程
        Thread thread1 = new Thread(m);
        thread1.setName("线程二");
        thread1.start();
    }
}
//创建一个类实现了Runnable接口
class MTherad implements Runnable{
//重写Runnable接口中的抽象方法
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            if (i % 2 == 0){
                System.out.println(Thread.currentThread().getName()+i);
            }

        }
    }
}

练习

例子：设计三个窗口买票，总票数为100张,使用Runnable接口的方法实现

public class WindowsRunnableTest {
    public static void main(String[] args) {

        WindowsRunnable w1 = new WindowsRunnable();
        Thread t1 = new Thread(w1);
        Thread t2 = new Thread(w1);
        Thread t3 = new Thread(w1);
        t1.setName("窗口一");
        t2.setName("窗口2");
        t3.setName("窗口三");
        t1.start();
        t2.start();
        t3.start();
    }
}

class WindowsRunnable implements Runnable{
    private  int tickets = 100;//不用必须用static修饰
    int total = 0;
    int sun = 0;
    @Override
    public void run() {
        while (true){
            if (tickets > 0){
                tickets--;
                System.out.println(Thread.currentThread().getName()+":"+"卖出一张票"+"票号为：" +tickets);
                total++;
                sun++;
            }else if(tickets == 0){
                System.out.println("一共卖出票"+total+"张");
                System.out.println(Thread.currentThread().getName()+"一共卖出票"+sun+"张");

                break;
            }
        }
    }
}

比较创建线程的两种方式

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

实现的方式没有类的单继承性的局限性
实现的方式更适合来处理多个线程有共享数据的情况

联系：Thread也实现了Runnable接口
相同点：都需要重写run（）方法，将线程要自信的逻辑声明在run（）中

线程的生命周期

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

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

状态
就绪：处于新建状态的线程被start()后，将进入线程队列等待CPU时间片，此时它已

具备了运行的条件，只是没分配到CPU资源
运行：当就绪的线程被调度并获得CPU资源时,便进入运行状态， run()方法定义了线

程的操作和功能
阻塞：在某种特殊情况下，被人为挂起或执行输入输出操作时，让出 CPU 并临时中

止自己的执行，进入阻塞状态
死亡：线程完成了它的全部工作或线程被提前强制性地中止或出现异常导致结束

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-N3BBztov-1598422376911)(/home/xys/Desktop/深度截图_选择区域_20200826140153.png)]

线程的同步（重难点，解决线程安全问题）

多线程出现了安全问题
问题的原因：当多条语句在操作同一个线程共享数据时，一个线程对多条语句只执行了一部分，还没有执行完，另一个线程参与进来执行。导致共享数据的错误。
解决办法：对多条操作共享数据的语句，只能让一个线程都执行完，在执行过程中，其他线程不可以参与执

多个线程执行的不确定性引起执行结果的不稳定

银行取钱，老婆自己共用一个账户

多个线程对账本的共享，会造成操作的不完整性，会破坏数据

线程的安全问题

问题：买票的过程中出现了重票，错票–》出现了线程安全性错误
出现问题的原因：当某个线程操作车票的过程中，尚未操作完成时，其他线程参与进来，，也操作了车票
车票是共享数据
.如何解决：加上锁，当一个线程操作票数时，其他线程不能参与进来，直到线程A操作完其他线程才可以开始操作
票数ticket从。这种情况下线程a及时被阻塞，也不能被改变
java中我们通过同步机制来解决线程安全问题、
方式一：同步代码块
synchronize（同步监视器）{
//需要被同步的代码
}
说明P：操作共享数据的代码即为需要被同步的代码
共享数据：多个线程共同操作的变量。比如本问题中的ticket————不能包含代码多了，也不必少了
同步监视器：俗称：锁。任何一个类的对象都可以来充当锁
要求：多个线程必须要共用同一把锁，共用充当锁的类对象
补充，在实现Runnable接口创建多线程的方式中，我们可以考虑使用this来充当同步监视器的锁

方式二：同步方法
如果操作共享数据的代码完整的声明在一个方法中，那么我们可以将这个方法声明成同步的、
```
关于同步方法的总结
1.同步方法扔涉及到同步监视器，只是不需要显示的声明
2.非静态的同步方法，同步监视器是：this
  静态的同步方法，同步监视器是当前类本身：类名称.class
```
使用同步方式，解决了程的安全性问题

但是操作同步代码时，只能有一个线程参与执行，其他线程等待，相当于是一个单线程的过程，效率变低了
*/

使用同步代码块的方式解决实现Runnable接口的多窗口买票问题

public class WindowsRunnableTest {
    public static void main(String[] args) {

        WindowsRunnable w1 = new WindowsRunnable();
        Thread t1 = new Thread(w1);
        Thread t2 = new Thread(w1);
        Thread t3 = new Thread(w1);
        t1.setName("窗口1");
        t2.setName("窗口2");
        t3.setName("窗口3");
        t2.start();
        t1.start();
        t3.start();
    }
}

class WindowsRunnable implements Runnable{
    private  int tickets = 100;//不用必须用static修饰
    Object obj = new Object();
    int i1 = 0;
    int i2 = 0;
    int i3 = 0;
    int total = 0;
    @Override
    public void run() {
        while (true){
            try {
                Thread.sleep(50);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            synchronized(this) {
                if (tickets > 0) {
                    System.out.println(Thread.currentThread().getName() + ":" + "卖出一张票" + "票号为：" + tickets);
                    tickets--;
                    if (Thread.currentThread().getName().equals("窗口1")){
                        i1++;

                    }else if (Thread.currentThread().getName().equals("窗口2")){
                        i2++;
                    }else if (Thread.currentThread().getName().equals("窗口3")){
                        i3++;
                    }
                total++;
//                sun++;
                } else {

                    System.out.println("一共卖出票"+total+"张");

                    if (Thread.currentThread().getName().equals("窗口1")){
                        System.out.println(Thread.currentThread().getName()+"一共卖出票"+i1+"张");
                    }else if (Thread.currentThread().getName().equals("窗口2")){
                        System.out.println(Thread.currentThread().getName()+"一共卖出票"+i2+"张");
                    }else if (Thread.currentThread().getName().equals("窗口3")){
                        System.out.println(Thread.currentThread().getName()+"一共卖出票"+i3+"张");
                    }

                    break;
                }
            }
        }
    }
}

线程的同步之懒汉单例模式

/*
使用同步机制将单例模式的懒汉式改写成安全模式
 */
public class BankTest {
}

class Bank {

    private Bank() {
    }

    private static Bank instance = null;

    public static Bank getInstance() {
        //方式一效率低，
//        synchronized (Bank.class) {
//            if (instance == null) {
//                instance = new Bank();
//            }
//            return instance;
//        }
        //方式二.效率高
        if (instance == null) {
            synchronized (Bank.class) {
                if (instance == null) {
                    instance = new Bank();
                }
            }
        }
        return instance;
    }
}

线程的死锁

1.死锁的理解：不同的线程分别占用对方需要的同步资源不放弃都等待对方放弃自己需要的同步资源，就形成的线程的死锁
2.说明：
1. 出现死锁后，不会出现异常，不会出现提示，只是所有的线程都处于阻塞状态，无法继续
2. 我们使用同步时，要避免出现死锁

解决线程安全问题方式三：lock锁-----jdk5.0新增

面试题：synchronize和lock的异同
同:二者都可以解决线程安全问题
不同：synchronize疾指在执行完相应的代码后，自动释放同步监视器
lock需要手动启动同步lock(），执行完相应代码后也需要手动结束同步unlock（）

2.优先使用顺序
lock—》同步代码块（已经进入了方法体，分配了相应资源—》《同步方法（在方法体之外）

示例代码

public class LockTest {
    public static void main(String[] args) {
        Window w = new Window();
        Thread h1 = new Thread(w);
        Thread h2 = new Thread(w);
        Thread h3 = new Thread(w);

        h1.setName("窗口一");
        h2.setName("窗口二");
        h3.setName("窗口三");

        h1.start();
        h2.start();
        h3.start();

    }
}

class Window implements Runnable {
    private int ticket = 1000;
    //1.实例化一个ReenTrantLock对象啊
    private ReentrantLock lock = new ReentrantLock();

    @Override
    public void run() {
        while (true) {
            try {
                //2调用lock（）方法
                lock.lock();
                if (ticket > 0) {
                    try {
                        Thread.sleep(50);

                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread().getName() + ":" + "打印的票号为：" + ticket);
                    ticket--;
                } else {
                    break;
                }
            } finally {
                lock.unlock();
            }
        }
    }
}

线程的通信

线程通信的例子：使用两个线程打印1-100，线程交替打印
涉及到三个方法：
wait（）：一旦执行到此方法线程进入阻塞状态，并释放同步监视器
notify（）：一旦执行到此方法，就会唤醒一个被阻塞的线程，优先级高的先被唤醒
notifyAll：一旦执行到此方法，唤醒其他所有的被阻塞的方法

注意：

wait（），noyify（），notifyAll（）三个方法必须使用在同步代码块或者同步方法中
wait（），noyify（），notifyAll（）三个方法的调用者必须是同步代码块，或者同步方法中的同步监视器否则会出现异常
wait（），noyify（），notifyAll（）三个方法是定义在java.lang.Object类中，而且这三个方法不能被重写，因为使用final修饰的

面试题：
sleep（）和wait（）的一题？

相同点：一旦执行到方法都可以让当前线程进入阻塞状态
不同点：
1. 1两个方法声明的位置不同：thread类中声明sleep（），Object类中声明wait（）
2. 调用的要求不同：sleep2（）可以在任何需要的场景下调用，wait（）必须在同步代码块或同步方法中
```
    3. 关于是否释放同步监视器：如果两个方法都使用在同步代码块或者同步方法中，sleep（）不会释放同步监视器，二wait（）会释放同步监视器
```

示例代码

public class CommunicationTest {
    public static void main(String[] args) {
        Number n1 = new Number();
        Thread t1 = new Thread(n1);
        Thread t2 = new Thread(n1);
        Thread t3 = new Thread(n1);

        t1.setName("线程1");
        t2.setName("线程2");
        t3.setName("线程3");
        t1.start();
        t2.start();
        t3.start();

    }
}

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();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                } else {
                    break;
                }
            }
        }
    }
}

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

新增方式一：实现Callable

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

相比run()方法，可以有返回值
方法可以抛出异常
支持泛型的返回值
需要借助FutureTask类，比如获取返回结果

实现Callable接口 -----jdk5.0新增

创建一个Callable接口是实现类
实现call方法，将此线程需要执行的操作放在call方法中
创建Callable接口的实现类对象
将此callable接口的实现按类对象作为参数传到FutureTask构造其中，创建FutureTask的对象
将FutureTask的对象作为参数传递到Therad类的构造器中，创建Thread对象，并调用start方法
获取callable中的call方法中的方返回值

如何理解实现callable接口的方式比实现Runnable接口的方式更强大

Call（）可以有返回值的
Call（）可以抛出异常，被外面的操作捕获，获取异常信息
Callable是支持泛型的

示例代码

public class ThreadNew {
    public static void main(String[] args) {
        CallableTest c = new CallableTest();
        FutureTask f = new FutureTask(c);
        Thread t = new Thread(f);
        t.start();
        try {
            int vale = (int) f.get();
            System.out.println("总和："+ vale);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
    }
}

class CallableTest implements Callable{

    @Override
    public Object call() throws Exception {
        int sum = 0;
        for (int i = 0; i <= 100; i++) {
            sum+=i;

        }
        return sum;
    }
}

创建线程的方式，创建线程池

提供指定线程数量的线程池
执行指定的线程操作，需要提供实现Runnable接口或者Callable接口实现类对象
关闭连接池

好处：

提高了响应速度，减少了创建新线程的时间
降低资源消耗，重复利用线程池中的线程，不需要每次都创建
便于线程管理

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

示例代码

public class ThreadPool {
    public static void main(String[] args) {
        //提供指定线程数量的线程池
        ExecutorService service = Executors.newFixedThreadPool(10);
        //执行指定的线程操作，需要提供实现Runnable接口或者Callable接口实现类对象
        service.execute(new NumberThread());
        service.execute(new NumberThread1());//时候Runnable接口
//        service.submit();适合Callable接口
        //关闭线程池
        service.shutdown();

    }
}

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);
            }

        }
    }

Java之多线程

入谷第十天——多线程

线程

线程的分类

线程的创建和使用

方式一：继承Thread类

Thread中的常用方法

线程的优先级等级

练习1

创建多线程的方式二，实现Runnable接口

练习

比较创建线程的两种方式

线程的生命周期

线程的同步（重难点，解决线程安全问题）

线程的安全问题

线程的死锁

线程的通信

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

新增方式一：实现Callable

创建线程的方式，创建线程池

Java之多线程

mysql slave节点多线程复制

如何开启多线程

MySQL(五) 主从复制 – 开启并发SQL线程复制

使用多线程查询百万条用户数据将汉字转化成拼音

mysql5.6 基于GTID及多线程复制详解

java之多线程

effective java 3th item1：考虑静态工厂方法代替构造器

Java Json 数据下划线与驼峰格式进行相互转换

python开启多线程