java多线程详细解释

一. 进程的概念

程序本身是一个静态的概念，是数据的集合。而进程是一个动态的概念，程序运行起来就是一个进行。可以理解为一项任务，任务没有启动，未执行的时候就是程序本身，只是编写好了方案（程序），但是方案启动之后，就需要人员加入，需要工作参与，需要资源调配，需要执行进度显示等等（进程可以类似看作这个任务启动后的场景）。

二. 线程的概念

1. 线程就是进程执行的路径，就是这些路径保证进程的执行结果和执行方式

（可以这么看，进程是一项任务方案启动后的场景，那么线程就是方案的落实，具体到怎么做，怎么实现任务，通过人员调配（线程方法），资源的分配（jvm虚拟机），通过这些路径，这些资源和方法，将一个任务完成的过程，所以多线程其实就是多个路径去实现这个任务的过程。）

2. 多线程

多线程的前提是需要有cpu多核处理器，例如我们的大脑就是一个cpu，但是我们只有一个大脑，是单核处理器，我们在吃饭的时候还可以刷手机，看起来是同时进行的，其实大脑的处理是交替执行的，可以这么说，我们的大脑一边执行刷手机这个行为，一边执行吃饭这个行为，这两个行为是交替的，处理的时间很短，所以看起来同时进行一样。

同理：单线程的执行也是一样，是交替执行的，处理时间短暂，并且每个线程完成不同的行为。

多个线程占用cpu资源，交替执行。

注意：真正的多线程是多核的，也就是需要cpu有多核处理，同时执行不同的动作。注意是同时而不是切换交替执行。

三.创建线程的方式

1.继承Tread类

public class MyThread extends Thread{
    static int number = 0;
    String name = "";
    String lock = "lock";
    MyThread(String name){
        this.name = name;
    }
    @Override
    public void run() {
        synchronized (lock) {
            for (int i = 0; i < 10; i++) {
                number = number + 1;
                System.out.println(name + number);
                if (number >=5){
                    System.out.println("超过一半停止");
                    break;
                }
            }
        }
    }

    public static void main(String[] args) {
        MyThread myThreadA = new MyThread("ThreadA");
        myThreadA.start();
        MyThread myThreadB = new MyThread("ThreadB");
        myThreadB.start();
    }
}

2.实现Runnable接口

package com.example.activity.thread;

public class RunnableThread implements Runnable{
    static int number = 0;
    String name = "";
    String lock = "lock";
    RunnableThread(String name){
        this.name = name;
    }
    @Override
    public void run() {
            for (int i = 0; i < 10; i++) {
                number = number + 1;
                System.out.println(name + number);
            }
    }

    public static void main(String[] args) {
        RunnableThread runnableThreadA = new RunnableThread("ThreadA");
        RunnableThread runnableThreadB = new RunnableThread("ThreadB");
        new Thread(runnableThreadA).start();
        new Thread(runnableThreadB).start();
    }
}

3.实现Callable类

package com.example.activity.thread;

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;

public class CallablesThread implements Callable {
    @Override
    public Object call() throws Exception {

        return "callableThread";
    }

    public static void main(String[] args) throws ExecutionException, InterruptedException {
        CallablesThread thread = new CallablesThread();
        FutureTask task = new FutureTask(thread);
        new Thread(task).start();
        System.out.println(task.get());
    }
}

callable类通过future包装器创建线程，同时通过get方法获取线程的返回对象

注意：如果线程没有返回，get会一直阻塞，一直等待返回。

这几种方式都是常见的方式，也可以通过线程池创建。

四.线程的状态和调用的方法

下图描述了线程的状态和调用方法之后的状态，图片是拉取博客上其他文章的图片。

 Runnable就绪状态，Running运行状态，new创建状态，Blocked阻塞状态，Dead结束状态

Runnable就绪状态一直在等待cpu资源的到来，只有cpu资源到来才能到运行状态，运行状态Running调用wait方法，线程进入等待状态，使用synchronized将线程锁定（其他线程不能进入，保证同步，下面再讲），调用join方法将线程插队到其他状态中，使用yield方法使线程进入就绪状态。当sleep()状态超时、join()等待线程终止或者超时、或者I/O处理完毕时，线程重新转入就绪状态。

五.多线程和线程池的使用

可以查看另一篇文章，写的不错

Java使用多线程做批处理（查询大量数据）_线程池 批量查询处理_nianyuw的博客-CSDN博客