文章/答案/技术大牛

发布

社区首页 >专栏 >Java-多线程

Java-多线程

WuShF

发布于 2023-07-08 07:50:38

22300

代码可运行

文章被收录于专栏：笔记分享笔记分享

运行总次数：0

代码可运行

进程与线程

程序>进程>线程

程序是一段静止的代码，只有真正运行时的程序，才被称为进程。一个程序运行至少有一个进程从操作系统底层来说，进程只是一个概念，真正执行的是线程。

进程是操作系统资源分配的基本单位，而线程是CPU的基本调度单位。线程是进程中的一个执行路径，共享同一个进程内存空间。线程之间可以自由切换，并发执行，一个进程最少有一个一个线程。线程是CPU的基本调度单位。进程之间不能共享数据段地址，但同进程的线程之间可以。

单核CPU在任何时间点上，只能运行一个进程：宏观并行，微观串行。进程由多个线程组成，彼此之间完成不同的工作，交替执行，被称为多线程。对于一个Java程序，至少有两个线程。

main方法，也称主线程。
垃圾回收器GC，在JVM启动时自动启动。

线程的组成

任何一个线程都具有的基本组成部分： CPU时间片：操作系统会为每个线程分配执行时间。

不是我们去控制CPU，而是CPU根据操作系统为我们分配执行时间。

运行数据：

堆空间：存储线程需使用的对象，多个线程可以共享堆中的对象。
栈空间：存储线程需使用的局部变量，每个线程都拥有独立的栈。

线程的两种实现方式

并行与并发

并行：多个任务同时执行（多个CPU）。并发：多个任务同时请求运行，而处理器一次只能接受一个任务，就会把两个任务安排轮流执行，由于CPU时间片运行时间较短，就会感觉两个任务在同时执行。

创建线程一共有两种方式，分别是：继承Thread类和实现Runable方法。启动线程是通过调用start()方法，表示线程已经准备就绪，等待CPU分配时间片。一旦CPU分配了时间片，线程就会自动运行。 start()方法不是启动线程，而是说这个线程已经准备就绪，等待CPU调度。

继承Thread类

继承Thread类
覆盖run()方法
创建子类对象
调用start()方法

public class Main {
    public static void main(String[] args) {
        //创建子类对象
        MyThread myThread = new MyThread();
        //调用start()方法
        myThread.start();
    }
}

//继承Thread类
class MyThread extends Thread {
    @Override
    //重写run方法
    public void run() {
        for (int i = 0; i < 100; i++)
            System.out.println(i);
    }
}

实现Runable方法

实现Runable接口类
覆盖run()方法
创建实现类对象
创建线程对象
调用start()方法

public class Main {
    public static void main(String[] args) {
        //创建实现类对象
        MyRunable myRunable = new MyRunable();
        //创建线程对象
        Thread thread = new Thread(myRunable);
        //调用start方法
        thread.start();
    }
}

//实现Runable接口类
class MyRunable implements Runnable {
    @Override
    //重写run方法
    public void run() {
        for (int i = 0; i < 100; i++)
            System.out.println(i);
    }
}

如果使用类的方式来创建线程，代码看起来更加方便简单。如果使用接口的方式来创建线程，要先编写任务，然后将任务交给线程类才能启动。要多一个步骤，看起来更加麻烦。但更常用的还是接口的方式，因为接口更加灵活，可以继承多个。如果使用类的方法，那么将无法继承其他的类。而如果使用接口，那么仍然可以继承其他的类，不会被因承继Thread类限制住。

接口回调

我们通过线程往外返回结果的时候，直接返回是没有办法返回数据的。可以通过接口调用的方法传递数据。也就是在线程内部定义一个接口，谁需要返回数据，谁里面就定义一个接口，来做数据的返回。

模拟一个系统登陆功能，使用随机验证码来防止暴力破解方式进行不断的登陆尝试。实现要求：利用线程实现生成4位验证码，要求验证码由数字、字母组成，生成后显示出来。然后用户输入验证码，判断验证码是否正确。

import java.util.Random;
import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        ValidateCodeThread validateCodeThread = new ValidateCodeThread();
        ValidateCodeThread.OnResultListener onResultListener = new ValidateCodeThread.OnResultListener() {
            @Override
            public void onResult(String result) {
                Scanner scanner = new Scanner(System.in);
                System.out.println("请输入验证码：");
                String userCode = scanner.nextLine();
                System.out.println(result.equals(userCode));
            }
        };
        validateCodeThread.setOnResultListener(onResultListener);
        Thread thread = new Thread(validateCodeThread);
        thread.start();

    }
}

//创建验证码的线程任务
class ValidateCodeThread implements Runnable {
    private String codes = "23456789abcdefghjkmnpqrstuvwxyz";
    private OnResultListener onResultListener;

    public void setOnResultListener(OnResultListener onResultListener) {
        this.onResultListener = onResultListener;
    }

    Random r = new Random();
    int num = 4;
    StringBuffer sb = new StringBuffer(4);

    @Override
    public void run() {
        for (int i = 0; i < num; i++) {
            int index = r.nextInt(codes.length());
            sb.append(codes.charAt(index));
        }
        System.out.println("生成的验证码是" + sb);
        if (onResultListener != null) {
            onResultListener.onResult(sb.toString());
        }
    }

    interface OnResultListener {
        public void onResult(String result);
    }
}

线程休眠

public static native void sleep(long millis) throws InterruptedException; 只要使用native修饰的方法都是本地方法。此方法不是由Java实现，而是由底层的C/C++实现，然后回调到sleep方法。

数列中随机生成不重复数

需求：从1~100中随机产生10个不重复的数。

普通的算法逻辑：

随机生成第一个数，放到结果数组的第0个位置。
随机生成第二个数，与结果数组中已存在的数比较，如果相同，重新生成，直到不同，放到结果数组中。
重复第2步，直到生成10个数结束。

import java.util.Arrays;
import java.util.Random;

public class Main {
    public static void main(String[] args) {
        int[] ints = new int[100];
        for (int i = 0; i < 100; i++) {
            ints[i] = i + 1;
        }
        int[] result = new int[10];
        boolean flag = true;
        Random random = new Random();
        for (int i = 0; i < result.length; i++) {
            flag = true;
            while (flag) {
                boolean b = true;
                int index = random.nextInt(ints.length);
                for (int j = 0; j < i; j++) {
                    if (ints[index] == result[j]) {
                        b = false;
                        break;
                    }
                }
                if (b) {
                    result[i] = ints[index];
                    flag = false;
                }
            }
        }
        System.out.println(Arrays.toString(result));
    }
}

优化后的算法逻辑

我们可以将随机的元素与数组末尾的元素进行交换，下次取值的时候通过数组元素个数减1的方式来随机产生一个数。

import java.util.Arrays;
import java.util.Random;

public class Main {
    public static void main(String[] args) {
        int[] ints = new int[100];
        for (int i = 0; i < ints.length; i++) {
            ints[i] = i + 1;
        }
        int[] result = new int[10];
        Random random = new Random();
        for (int i = 0; i < result.length; i++) {
            int index = random.nextInt(ints.length - i);
            result[i] = ints[index];
            ints[ints.length - 1 - i] = ints[index] + ints[ints.length - 1 - i];
            ints[index] = ints[ints.length - 1 - i] - ints[index];
            ints[ints.length - 1 - i] = ints[ints.length - 1 - i] - ints[index];
        }
        System.out.println(Arrays.toString(result));
    }
}

添加休眠功能

使用Thread.sleep(long millis)方法实现线程休眠。使用Thread.sleep(long millis)可能返回中断，需要用try-catch语句包裹。

import java.util.Random;

public class Main {
    public static void main(String[] args) {
        GenRandomNums genRandomNums = new GenRandomNums();
        Thread thread = new Thread(genRandomNums);
        thread.start();
    }
}

class GenRandomNums implements Runnable {
    @Override
    public void run() {
        int[] ints = new int[100];
        for (int i = 0; i < ints.length; i++) {
            ints[i] = i + 1;
        }
        int[] result = new int[10];
        Random random = new Random();
        for (int i = 0; i < result.length; i++) {
            int index = random.nextInt(ints.length - i);
            result[i] = ints[index];
            ints[ints.length - 1 - i] = ints[index] + ints[ints.length - 1 - i];
            ints[index] = ints[ints.length - 1 - i] - ints[index];
            ints[ints.length - 1 - i] = ints[ints.length - 1 - i] - ints[index];
        }
        for (int i = 0; i < result.length; i++) {
            System.out.print(result[i] + " ");
            try {
                Thread.sleep(500);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

        }
    }
}

自定义标记中断线程

中断线程可以利用方法对象.interrupt();为线程打上中断标记，在线程内使用Thread.interrupted()方法判断是否中断，该方法的返回值为Boolean类型，根据返回值判断接下来的操作。 Java提供的中断方法并不会强行结束线程，只是为线程打上中断标记。如何中断交由线程自己决定。也可以在类内添加标记flag，通过在类外手动为flag赋值，根据不同的值进行不同的操作，实现中断功能。

class GenRandomNums implements Runnable {
    @Override
    public void run() {
        Boolean flag = true;
        int[] ints = new int[100];
        for (int i = 0; i < ints.length; i++) {
            ints[i] = i + 1;
        }
        int[] result = new int[10];
        Random random = new Random();
        for (int i = 0; i < result.length && flag; i++) {
            int index = random.nextInt(ints.length - i);
            result[i] = ints[index];
            ints[ints.length - 1 - i] = ints[index] + ints[ints.length - 1 - i];
            ints[index] = ints[ints.length - 1 - i] - ints[index];
            ints[ints.length - 1 - i] = ints[ints.length - 1 - i] - ints[index];
        }
        for (int i = 0; i < result.length && flag; i++) {
            System.out.print(result[i] + " ");
            try {
                Thread.sleep(500);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

        }
    }
}

获取线程名称

Thread.currentThread().getName()会返回当前线程的名称。

import java.util.Random;

public class Main {
    public static void main(String[] args) {
        ThraedName thraedName = new ThraedName();
        Thread thread = new Thread(thraedName);
        thread.start();
        //main:main
        System.out.println("main:" + Thread.currentThread().getName());
        //thread:Thread-0
        System.out.println("thread:" + thread.getName());
    }
}

class ThraedName implements Runnable {
    @Override
    public void run() {
        //GenRandomNums:Thread-0
        System.out.println("GenRandomNums:" + Thread.currentThread().getName());
    }
}

线程同步与安全性

线程安全问题

多个线程操作同一个数据出现的数据不统一问题。

public class Main {
    public static void main(String[] args) {
        TicketThread ticketThread = new TicketThread();
        Thread t1 = new Thread(ticketThread);
        Thread t2 = new Thread(ticketThread);
        Thread t3 = new Thread(ticketThread);
        Thread t4 = new Thread(ticketThread);
        t1.start();
        t2.start();
        t3.start();
        t4.start();
    }
}

class TicketThread implements Runnable {
    private int num = 10;

    @Override
    public void run() {
        while (num != 0) {
            System.out.println(Thread.currentThread().getName() + "-当前:" + num-- + "剩余" + num);
            try {
                Thread.sleep(500);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

线程同步

只有拥有对象互斥锁标记的线程，才能进入该对象加锁的同步代码块。线程退出同步代码块时，会释放相应的互斥锁标记。需要注意的是，sleep()方法不会释放锁。

synchronized()同步代码块

synchronized(要同步的对象){要同步的操作} 括号内"要同步的对象"只是一个标记作用，没有其他含义。

//同步代码块
synchronized (this) {
    while (num != 0) {
        System.out.println(Thread.currentThread().getName() + "-当前:" + num-- + "剩余" + num);
        try {
            Thread.sleep(500);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

同步方法

同步的对象是当前对象。

//同步方法，同步的对象是当前对象
private synchronized void ticket() {
    while (num != 0) {
        System.out.println(Thread.currentThread().getName() + "-当前:" + num-- + "剩余" + num);
        try {
            Thread.sleep(500);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

Lock.lock();锁同步

更加灵活，可以自定义同步区域。

private Lock lock = new ReentrantLock();

@Override
public void run() {
    if (lock.tryLock()) {
        lock.lock();
    }
    while (num != 0) {
        System.out.println(Thread.currentThread().getName() + "-当前:" + num-- + "剩余" + num);
        try {
            Thread.sleep(500);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }
}

同步规则

只有在调用包含同步代码块的方法，或者同步方法时，才需要对象的锁标记。如调用不包含同步代码块的方法，或普通方法时，则不需要锁标记，可直接调用。 Java中线程安全的类包括：StringBuffer类、集合类等，这些类的公开方法均为synchonized修饰的同步方法。

如果需求中存在多线程同时访问，那么建议使用StringBuffer类。如果只有一个线程，那么建议使用StringBuilder类。同步会增加性能的消耗，但在多线程的时候又不得不使用同步，否则会出现数据错乱、数据不安全的问题。通常是用确保数据安全换取性能的牺牲。性能和安全是相辅相成的。

死锁问题

如果线程进行同步，那么他就会上锁，此时如果其他线程如果要执行，就要在门口等待，就会出现死锁：想要获取这个锁，但一直获取不到。

线程池

线程是宝贵的内存资源，单个线程占用约1M左右的内存空间，过多分配容易造成内存溢出。频繁的创建和销毁线程会增加虚拟机回收频率造成程序性能下降。

线程池

线程容器，可设定线程分配的数量上限。将预先创建的线程对象存入池中，并重用线程池中的线程对象。避免频繁的创建和销毁。

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

public class Main {
    public static void main(String[] args) {
        //创建三个线程的线程池
        ExecutorService executorService = Executors.newFixedThreadPool(3);
        //提交到任务队列
        executorService.submit(new TicketThread());
        executorService.submit(new TicketThread());
        executorService.submit(new TicketThread());
        executorService.submit(new TicketThread());
    }
}

class TicketThread implements Runnable {
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName());
    }
}

多线程应用

生产者与消费者的协作案例

this.wait();//线程进入等待状态，把CPU时间片让出去，释放监视器所有权（对象锁），等待其他方法使用notify()方法唤醒。 Thread.sleep();///线程进入休眠状态，把CPU时间片让出去，但不会释放对象锁 this.notify();//按优先级唤醒等待中的一个线程

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

public class Main {
    public static void main(String[] args) {
        Food food = new Food();
        Producter p = new Producter(food);
        Customers c = new Customers(food);
        Thread thread1 = new Thread(p);
        Thread thread2 = new Thread(c);
        thread2.start();
        thread1.start();
    }
}

class Customers implements Runnable {
    private Food food;

    public Customers(Food food) {
        this.food = food;
    }

    @Override
    public void run() {
        for (int i = 0; i < 20; i++) {
            food.get();
        }
    }
}

class Producter implements Runnable {
    private Food food;

    public Producter(Food food) {
        this.food = food;
    }

    @Override
    public void run() {
        for (int i = 0; i < 20; i++) {
            if (i % 2 == 0) {
                food.set("牛肉拉面", "味道美极了");
            } else {
                food.set("韭菜炒鸡蛋", "大补啊");
            }
        }
    }
}

class Food {
    private String name;
    private String desc;
    Boolean flag = true;//true表示可以生产,false表示可以消费

    //生产食物
    public synchronized void set(String name, String desc) {
        //如果能消费不能生产
        if (!flag) {
            try {
                //线程进入等待状态，释放监视器所有权（对象锁）
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        this.name = name;
        try {
            Thread.sleep(500);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        this.desc = desc;
        //生产完成，可以消费
        flag = false;
        //按优先级唤醒等待中的一个线程
        this.notify();
    }

    //获取食物
    public synchronized void get() {
        //如果能生产不能消费
        if (flag) {
            try {
                //线程进入等待状态，释放监视器所有权（对象锁）
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        try {
            Thread.sleep(500);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(name + "->" + desc);
        //消费完成，可以生产
        flag = true;
        //按优先级唤醒等待中的一个线程
        this.notify();
    }

}

线程隔离

ThreadLocal提供一个线程Thread局部变量，访问到某个变量的每一个线程都拥有自己的局部变量。可以在多线程环境下保证成员变量的安全。 ThreadLocal并不是用来解决多线程环境下共享变量的问题。而是用来提供线程内部共享变量的问题。

对比synchronized

ThreadLocal是采用空间换时间的方式，为每一个线程都提供一份变量的副本，实现同时访问、互不干扰，在多线程当中让每个线程之间的数据相互隔离。 synchronized同步机制采用的是时间换空间的方式，只提供一份，让线程排队访问，在多线程之间访问资源同步。

import java.lang.Thread;

public class Main {
    public static void main(String[] args) {
        MyThread myThread = new MyThread();
        Thread thread1 = new Thread(myThread);
        Thread thread2 = new Thread(myThread);
        thread1.start();
        thread2.start();
    }
}

class MyThread implements Runnable {
    private static ThreadLocal<Integer> threadLocal = new ThreadLocal<>();

    @Override
    public void run() {
        for (int i = 0; i < 3; i++) {
            threadLocal.set(i);
            System.out.println(Thread.currentThread().getName() + "threadLocal.get()=" + threadLocal.get());
        }
    }
}