线程

在操作系统中，线程是比进程更小的能够独立运行的基本单位。同时，它也是CPU调度的基本单位。

线程本身基本上不拥有系统资源，只是拥有一些在运行时需要用到的系统资源，例如程序计数器、寄存器和栈等。

一个进程中的所有线程可以共享进程中的所有资源。

多线程

多线程可以理解为同一个程序中能够同时运行多个不同的线程来执行不同的任务，

这些线程可以同时利用CPU的多个核心运行。

多线程编程能够最大限度的利用CPU资源，如果某一个线程的处理不需要占用CPU资源时，（例如IO线程），

可以使当前线程让出CPU资源以使其他线程能够获取到CPU资源，进而能够执行其他线程对应的任务，

达到最大化利用CPU资源的目的

线程的实现方式

在Java中，实现线程的方式分为三种：

1.继承Thread类

2.实现Runnable接口

3.实现Callable接口

1.通过继承Thread类

2.通过实现Runnable接口

3.通过实现Callable接口

代码

package com.breeze.concurrent.chapters1;

import java.util.concurrent.*;

/**
 * 1.线程
 * 在操作系统中，线程是比进程更小的能够独立运行的基本单位。同时，它也是CPU调度的基本单位。
 * 线程本身基本上不拥有系统资源，只是拥有一些在运行时需要用到的系统资源，例如程序计数器、寄存器和栈等。
 * 一个进程中的所有线程可以共享进程中的所有资源。
 *
 * 2.多线程
 * 多线程可以理解为同一个程序中能够同时运行多个不同的线程来执行不同的任务，
 * 这些线程可以同时利用CPU的多个核心运行。
 * 多线程编程能够最大限度的利用CPU资源，如果某一个线程的处理不需要占用CPU资源时，（例如IO线程），
 * 可以使当前线程让出CPU资源以使其他线程能够获取到CPU资源，进而能够执行其他线程对应的任务，
 * 达到最大化利用CPU资源的目的
 *
 * 线程的实现方式
 * 在Java中，实现线程的方式分为三种：
 * 1.继承Thread类
 * 2.实现Runnable接口
 * 3.实现Callable接口
 */

public class Therad {
    public static void main(String[] args) {
        System.out.println("这是主线程：" + Thread.currentThread());
        //1.继承Thread类
        Thread thread1 = new ThreadTest();
        thread1.start();

        //2.实现Runnable接口
        Thread thread2 = new Thread(new RunnableTest());
        thread2.start();
        //lambda写法
        Thread thread2_1 = new Thread(() -> {
            System.out.println("这是通过实现Runnable接口实现的线程：" + Thread.currentThread());
        });
        thread2_1.start();

        //3.实现Callable接口
        Callable callable = new CallableTest("测试");
        FutureTask<String> task = new FutureTask<String>(callable);
        Thread thread3 = new Thread(task);
        thread3.start();
    }

    /**
     * @author breeze
     * @description 继承Thread类实现
     */
    static class ThreadTest extends Thread{
        @Override
        public void run(){
            System.out.println("这是通过继承Thread类实现的线程：" + Thread.currentThread());
        }
    }

    /**
     * @author breeze
     * @description 实现Runnable接口
     */
    static class RunnableTest implements Runnable{
        public void run(){
            System.out.println("这是通过实现Runnable接口实现的线程：" + Thread.currentThread());
        }
    }

    /**
     * @author breeze
     * @description 实现Callable接口
     */
    static class CallableTest implements Callable<String>{
        private String str;
        public CallableTest(String str){
            this.str = str;
        }
        @Override
        public String call() throws Exception {
            System.out.println("这是通过实现Callable接口实现的线程：" + Thread.currentThread());
            return str;
        }
    }
}

代码执行结果

这是主线程：Thread[main,5,main]
这是通过继承Thread类实现的线程：Thread[Thread-0,5,main]
这是通过实现Runnable接口实现的线程：Thread[Thread-1,5,main]
这是通过实现Callable接口实现的线程：Thread[Thread-2,5,main]