Java多线程基础

---

前言

随着多核CPU的发展，并发编程能更充分的利用多核CPU的资源

---

一.什么是线程

线程（Thread）是操作系统能够进行运算调度的最小单位。它被包含在进程之中，是中的实际运作单位。一条线程指的是中一个单一顺序的控制流，一个进程中可以并发多个线程，每条线程并行执行不同的任务。

1.线程与进程

进程：进程（Process）是计算机中的程序关于某数据集合上的一次运行活动，是系统进行资源分配和调度的基本单位，是操作系统结构的基础。是程序在系统中的一次执行信息，不同进程之间是相互独立的。

进程与线程的区别

1. 进程是系统进行资源分配和调度的一个独立单位，线程是程序执行的最小单位。
2. 进程有自己的内存地址空间，线程只独享指令流执行的必要资源，如寄存器和栈。
3. 由于同一进程的各线程间共享内存和文件资源，可以不通过内核进行直接通信。
4. 线程的创建、切换及终止效率更高。

2.线程代码实例

    private static class MyThread extends Thread {
   
        //run方法为线程的核心方法，线程要干的所有事情都在run方法中进行定义
        public void run(){
   
            Random random = new Random();
            while(true){
   
                System.out.println(Thread.currentThread().getName());
                try {
   
                    Thread.sleep(random.nextInt(10));
                } catch (InterruptedException e) {
   
                    throw new RuntimeException(e);
                }
            }
        }
    }
    //主线程
    public static void main(String[] args) {
   
        MyThread t1 = new MyThread();
        MyThread t2 = new MyThread();
        MyThread t3 = new MyThread();
        t1.start();
        t2.start();
        t3.start();
        Random random = new Random();
        while(true){
   
            System.out.println(Thread.currentThread().getName());
            try {
   
                Thread.sleep(random.nextInt(10));
            } catch (InterruptedException e) {
   
                throw new RuntimeException(e);
            }
        }
    }
}

3 多线程的优势

1. 创建一个新线程的代价要比创建一个新进程小的多。
2. 与进程之间的切换相比，线程之间的切换需要操作系统做的工作小的多。
3. 线程占用的资源要比进程小很多。
4. 能充分利用多处理器可并行数量。
5. 在等待慢速I/O操作结束的同时，程序可执行其他的计算任务。
6. 计算密集型应用，为了能在多处理器系统上运行，将计算分解到多个线程中实现。
7. I/O密集性应用，为了提高性能，将I/O操作重叠。线程可以同时等待不同的I/O操作。

/**
 * 串行和并发的时间对比
 */
public class ThreadAdvantage implements Runnable{
   
    private static final long  COUNT= 10_0000_0000;

    public static void main(String[] args) throws InterruptedException {
   
        serial();
        concurrent();
    }

    private static void serial(){
   
        Long start = System.nanoTime();
        long a = 0;
        for (long i = 0; i < COUNT; i++) {
   
            a++;
        }
        long b = 0;
        for (long i = 0; i < COUNT; i++) {
   
            b++;
        }
        Long end = System.nanoTime();
        double alltime = (end - start) * 1.0 / 1000 /1000;
        System.out.println("顺序执行共耗时；" + alltime + "ms");
    }

    private static void concurrent() throws InterruptedException {
   
        Long start = System.nanoTime();
        Thread thread = new Thread();
        thread.start();
        long b = 0;
        for (long i = 0; i < COUNT; i++) {
   
            b++;
        }
        thread.join();
        long end = System.nanoTime();
        double alltime = (end - start) * 1.0 / 1000 /1000;
        System.out.println("并发执行共耗时；" + alltime + "ms");
    }

    @Override
    public void run() {
   
        long a = 0;
        for (long i = 0; i < COUNT; i++) {