Java多线程知识点总结

1. 知识点讲解

线程对象是通过 Thread 类来创建的；任务是通过 Runnable 接口来定义的

Thread 无参构造器

Thread 有参构造器

public Thread(Runnable target)

Thread 线程执行流程：

1、创建线程对象，同时指定任务

2、启动线程，线程进入就绪状态，等待获取 CPU 资源

3、线程拿到 CPU 资源，开始执行任务

Thread 类中定义了一个 Runnable target 成员变量，用来接收创建线程对象时传入的任务

1、创建线程对象，传入任务

2、将任务赋值给 target 成员变量

3、线程执行的时候，操作 target 成员变量

public void run() {
	if (target != null) {
		target.run();
	}
}

2. 实现多线程的三种方式

2.1 继承 Thread 类

public class MyThread extends Thread {
    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            System.out.println("=====MyThread=====");
        }
    }
}

public class Test {
    public static void main(String[] args) {
        MyThread myThread = new MyThread();
        myThread.run();
    }
}

2.2 实现 Runnable 接口

2.2.1 代码实现

public class Runnable1 implements Runnable {
    @Override
    public void run() {
        for (int i = 0; i < 5; i++) {
            System.out.println("=====Runnable1=====");
        }
    }
}

public class Runnable2 implements Runnable {
    @Override
    public void run() {
        for (int i = 0; i < 5; i++) {
            System.out.println("=====Runnable2=====");
        }
    }
}

public class Test {
    public static void main(String[] args) {
        Runnable runnable1 = new Runnable1();
        Thread thread1 = new Thread(runnable1);
        thread1.start();

        Runnable runnable2 = new Runnable2();
        Thread thread2 = new Thread(runnable2);
        thread2.start();
    }
}

2.2.2 代码实现优化：使用匿名内部类来减少类的定义

public class Test {
    public static void main(String[] args) {
        Thread thread = new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < 5; i++) {
                    System.out.println("=====使用匿名内部类来减少类的定义=====");
                }
            }
        });
        thread.start();
    }
}

2.2.3 代码实现优化：使用 lambda 表达式进一步简化代码

lambda 函数式编程：将方法的实现作为参数进行传值

public class Test {
    public static void main(String[] args) {
        Thread thread = new Thread(() -> {
            for (int i = 0; i < 5; i++) {
                System.out.println("=====使用 lambda 表达式进一步简化代码=====");
            }
        });
        thread.start();
    }
}

2.3 实现 Callable 接口

3. 实现多线程的两种方式对比：

（1）继承 Thread 类：将任务的实现写到了线程类中，耦合度太高

（2）实现 Runnable 接口：可以解决上述问题，实现解耦合

4. 线程休眠

线程休眠不在于谁调用 sleep，而在于 sleep 写在哪

5. SC项目多线程实践

package com.ruoyi.hardware.comb;

import java.io.IOException;
import java.net.ServerSocket;
import java.net.Socket;

/**
 * @Author: xinglibao
 * @Date: 2023/3/16 19:03
 */
public class ScSocketServer8080 extends Thread {
    @Override
    public void run() {
        try {
            ServerSocket serverSocket = new ServerSocket(8080);
            System.out.println("ScSocketServer8080启动成功");
            Socket socket = null;
            while (true) {
                socket = serverSocket.accept();
                ScSocketServerThread serverThread = new ScSocketServerThread(socket);
                serverThread.start();
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

package com.ruoyi.hardware.comb;

import java.io.FileOutputStream;
import java.io.InputStream;
import java.net.Socket;

/**
 * @Author: xinglibao
 * @Date: 2023/3/10 21:54
 */
public class ScSocketServerThread extends Thread {
    private Socket socket = null;

    public ScSocketServerThread(Socket socket) {
        this.socket = socket;
    }

    @Override
    public void run() {
        InputStream inputStream = null;
        FileOutputStream fileOutputStream = null;
        try {
            inputStream = socket.getInputStream();
            fileOutputStream = new FileOutputStream("/www/wwwroot/sc/data/concentrationMonitor.hex", true);
            int len = -1;
            byte[] bytes = new byte[8192];
            while ((len = inputStream.read(bytes)) != -1) {
                fileOutputStream.write(bytes, 0, len);
            }
        } catch (Exception e) {
            // TODO
        } finally {
            try {
                if (fileOutputStream != null) {
                    fileOutputStream.close();
                }
                if (inputStream != null) {
                    inputStream.close();
                }
                if (socket != null) {
                    socket.close();
                }
            } catch (Exception e) {
                // TODO
            }
        }
    }
}