Java多线程基础（一）_millitime-CSDN博客

这是结合自己所学总结，自己也正在学习道路上，本篇结合Guide哥的博客结合，自己所学的还处于基础的阶段，没了解这么深，通过它人的来补足自己的知识点的缺漏，如果你要了解更深，文章下有转载地址。
通过博客来记录自己的一滴滴成长，也许过程很艰辛，但我选择坚持，不给以后的自己留下遗憾。

一进程和多线程简介

1.1 进程和线程

进程
概念：程序的一次执行的过程，或是正在运行的一个程序
说明：进程作为资源分配单位，系统再运行时会为每个进程分配不同的内存区域
线程
概念;进程可进一步把细化为线程，是一个程序内部的一条执行路径。
说明：线程作为调度和执行的单位，每个线程拥有独立的运行栈和程序计数器（PC），线程切换的开销小
进程与线程
内存结构

1.2 何为进程？

进程是程序的一次执行过程，是系统运行的基本单位，因此进程是动态的。系统运行的一个程序即是一个进程从创建，运行到消亡的过程。

1.3何为多线程？

线程与进程相似，但线程是一个比进程更小的执行单位。一个进程在其执行的过程中可以产生多个线程。与进程不同的是同类的多线程共享同一块内存空间和一组系统资源，所以系统在产生一个线程，或是各个线程之间作切换工作时，负担要比进程小得多，也正是因为如此，线程也称为轻量级进程。

1.4何为多线程

多线程就是多个线程同时运行的或交替的运行。单核CPU的话是顺序执行，也就是交替执行。多核CPU的话，因为吗，每个CPU有自己的运算器，所以在多个CPU中可以同时运行。

1.5为什么多线程是必要的

个人感觉可以用一句话概括：开发高并发系统的基础，利用好多线程机制可以大大提高系统整体的并发能力及性能。

1.6 为什么提倡多线程而不是多线程

线程就是轻量级的进程，是程序执行的最小单位。使用多线程而不是用多线程去进行并发程序的设计，是因为线程之间的切花和调度的成本远小于进程。

二几个重要的概念

2.1 单核CPU与多核CPU的理解

单核CPU;其实就是一种假的多线程，因为在一个时间单元类，也只能执行一个线程的任务。就好比如：虽然有很多的车道，但是收费站只有一个工作人员在收费，只有收费才能过去，那么CPU就好比如收费人员。如果某个人不想交钱，那么收费人员就可以把他“挂起”（晾着他，等他相同了。准备好钱，再去收费）但是因为CP时间单位特别短，因此感觉不出来。
多核CPU：才能更好地发挥出多线程的效率。

一个Java应用程序java.exe，其实至少三个线程：main（）主线程，gc()垃圾回收线程，异常处理线程。当然如果发生异常，会影响主线程。

2.2 并行与并发的理解

**并行：**多个CPU同时执行多个任务。比如多个人做不同的事情。
**并发：**一个CPU（采用时间片）同时执行多个任务。比如：秒杀、多个人做同一件事

三创建多线程的方式

为了更好的理解，我把JDK 5及以前归纳在这里了。

3.1 继承Thread类的方式

创建一个继承类Thread类的子类
重写Thread类中的run() --> 将此线程的操作声明在run()中
创建Thread类的子类对象
通过此类对象调用start() ；
<1> 启动当前线程
<2> 调用当前线程的run()
代码示例：

class MyThread3 extends Thread {
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            if (i % 2 == 0) {
                System.out.println(Thread.currentThread().getName() + ":" + i);
            }
        }
    }
}

public class RevierTest {
    public static void main(String[] args) {
        MyThread3 m1 = new MyThread3();
        //设置线程名
        m1.setName("线程一");
        MyThread3 m2 = new MyThread3();
        //设置线程名
        m2.setName("线程二");

        //启动线程m1、m2
        m1.start();
        m2.start();
    }
}

运行结果:
在这里插入图片描述
说明两个问题：

问题一：我们在启动一个线程，必须调用start()，不能调用run()的方式启动线程
问题二: 如果在启动一个线程，必须创建一个Thread子类的对象，调用此对象start()

3.2 实现Runnable接口的方式

创建一个实现Runnable接口的类
实现类去实现Runable中的抽象方法：run（）
创建实现类的对象
将此对象作为参数传递Thread类的构造器中，创建Thread类的对象
通过Thread类的对象调用start()
代码示例:

class myThread implements Runnable{

    @Override
    public void run() {
        for(int  i = 0 ; i < 100; i++){
            if(i % 2 == 0){
                System.out.println(Thread.currentThread().getName()+":"+i);
            }
        }
    }
}
public class RevierTest {
    public static void main(String[] args) {
        myThread m1 = new myThread();
        Thread t1= new Thread(m1);
        t1.setName("线程一");
        t1.start();
    }

运行结果：
在这里插入图片描述
两种方式（Thread、Runable）的对比：

开发中：优先选择：实现Runable接口的方式
原因：
① 实现的方式没单继承性的局限
② 实现的方式更适合来处理多个线程共享数据的情况
联系： public class Thread implements Runable
相同点：
①两种方式都需要重写run()，将线程要执行的逻辑声明在run（）中
②目前这两种方式，要想启动线程，都是调用的Thread类中的start()

3.3 实现Callable接口。 —JDK5.0新增

代码示例：

class Number implements Callable {
    int sum = 0;

    //1.实现callable方法，将此方法需要执行的操作声明在call()
    @Override
    public Object call() throws Exception {
        for (int i = 0; i < 100; i++) {
            if (i % 2 == 0) {
                System.out.println(Thread.currentThread().getName() + ":" + i);
                sum += i;
            }
        }
        return sum;
    }
}

public class CallableTest {
    public static void main(String[] args) {
        //2.创建Callable接口实现类对象
        Number number = new Number();
        //3.将此Callable接口实现类的对象作为传递到FutureTak构造器中，创建FutureTask对象
        FutureTask f1 = new FutureTask(number);
        //4.将FutrueTask的对象作为参数传递到Thread类的构造器，创建Thread的对象
        Thread T1 = new Thread(f1);
        Thread T2 = new Thread(f1);
        //设置线程名、调用start()方法
        T1.setName("线程一");
        T1.start();

        T2.setName("线程二");
        T2.start();

        Object sum = null;
        try {
            //获取Callable中的call方法的返回值
            //get（）返回值即为Futruetask构造器参数Callable实现类重写call()的返回值
            sum = f1.get();
            System.out.println(sum);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }

    }
}

运行结果
在这里插入图片描述
说明：

如何理解实现Callable接口的方式创建多线程比实现Runnable接口创建多线程方式强大？
① call() 可以有返回值
② call() 可以抛出异常，被外面的操作捕获，获取异常的信息
③ callable是支持泛型的

3.4 使用线程池 — JDK5.0

代码示例：

class NuberThread 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 NuberThread1 implements  Runnable{

    @Override
    public void run() {
        for(int i =0; i <= 100; i++){
            if(i % 2!=0){
                System.out.println(Thread.currentThread().getName()+":"+i);
            }
        }
    }
}
public class ThreadPoolTest {
    public static void main(String[] args) {
        //提供指定的线程数量的线程池
        ExecutorService service = Executors.newFixedThreadPool(10);
        ThreadPoolExecutor severicel = (ThreadPoolExecutor) service;
        //设置线程池的属性
//        System.out.println(service.getClass());
//        service1.setCorePoolSize(15);
//        service1.setKeepAliveTime();

        //执行指定的线程的操作。需要提供实现Runnable接口或Callable接口实现类的对象
        //适用Callable接口
        service.execute(new NuberThread());
        service.execute(new NuberThread1());

        //适用Callable接口
        //service.submit(Callable callable);

        //关闭连接池
        service.shutdown();
    }
}