Java多线程基础（一）

这是结合自己所学总结，自己也正在学习道路上，本篇结合 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();
    }
}

运行结果：

说明：

① 提高响应速度（减少创建新线程的时间）
② 降低资源消耗（重复利用线程中的线程，不需要每次都创建）
③ 便于线程管理
corePoolSize:线程池的大小

    maximumPoolSize:最大线程数
    keepAliveTime:线程没任务时最多保持多长时间后会终止

四一些常用方法

4.1 start()

启动当前线程；调用当前线程的 run()

4.2 run()

通常需要重写 Thread 类中的此方法，将创建的线程要执行的操作声明在此方法中

4.3 currentThread()

静态方法，返回执行当前代码的线程

4.4 getName()

获取当前线程的名字

4.5 setName()

设置当前线程的名字

4.6 yield()

释放当前 cpu 的执行权

4.7 join()

在线程 a 中调用线程 b 的 join(),此时线程 a 就进入阻塞状态，直到线程 b 完全执行完以后，线程 a 才结束阻塞状态。

4.8 stop()

已过时。当执行此方法时，强制结束当前线程。

4.9 sleep(long millitime)

让当前线程“睡眠”指定的 millitime 毫秒。在指定的 millitime 毫秒时间内，当前线程是阻塞状态。

4.10 isAlive()

判断当前线程是否存活

4.11 线程的优先级

MAX_PRIORITY：10
MIN _PRIORITY：1
NORM_PRIORITY：5 –>默认优先级

4.12 获取和设置当前线程的优先级

getPriority():获取线程的优先级
setPriority(int p):设置线程的优先级
说明：高优先级的线程要抢占低优先级线程 cpu 的执行权。但是只是从概率上讲，高优先级的线程高概率的情况下被执行。并不意味着只当高优先级的线程执行完以后，低优先级的线程才执行。

4.13 补充：线程的分类

一种是守护线程，一种是用户线程。

五 Thread 的生命周期

5.1 图示

5.2 说明

生命周期关注两个概念：状态、相应的方法
关注：状态 a –> 状态 b：哪些方法执行了（回调方法）
某个方法主动调用:状态 a —> 状态 b
阻塞：临时状态，不可作为最终状态
死亡：最终的状态

线程的同步机制和线程通信放到多线程（二）。

转载地址

一 进程和多线程简介