进程与线程的含义

进程：

进程是代码在数据集合上的一次运行活动 ，是系统进行资源分配和调度的基本单位,一个进程可以有多个线程。

线程：

进程中的一个执行任务（控制单元），负责当前进程中程序的执行。一个进程至少有一个线程，一个进程可以运行多个线程，多个线程可共享数据。

操作系统在分配资源时是把资源分配给进程 的，但是 CPU 资源 比较特殊 ，它是被分配到线程的 ， 因为真正要占用 CPU 运行的是线程 ， 所以也说线程是 CPU 分配的基本单位。

个人理解的操作系统，cpu，进程，线程关系

线程和进程的关系

image.png

程序计数器

是为了记录线程执行的指令地址，因为线程是被轮转分配时间片的，所以需要记录上一次执行的指令地址，方便下一次找到执行指令继续执行。

栈

用来保存方法的局部变量，该变量是私有的，除此之外，栈还用来存放线程的调用栈帧。

堆

堆是一个进程中最大的一块内存，堆是被进程中的所有线程共享的，是进程创建时分配的，堆里面主要存放使用 new 操作创建的对象实例 。

另外需要注意 的是，如果执行的是 native 方法，那么 pc 计数器记录 的是 undefined 地址，只有执行的是 Java 代码时 pc 计数器记录的才是下一条指令 的地址 。

1.2 线程创建与运行

使用java创建线程有三种方式 1.继承Thread类 2.实现Runnable接口 3.使用Callable和Future

1.继承Thead类创建线程

（1）继承Thread类并重写run方法 （2）创建线程对象 （3）调用该线程对象的start()方法来启动线程

public class CreateThreadTest {
public static void main(String[] args) {
    new ThreadTest().start();
    new ThreadTest().start();
    }
}
class ThreadTest extends Thread{
private int i = 0;
    @Override
    public void run() {
        for (; i < 100; i++) {
            System.out.println(Thread.currentThread().getName() + " is running: " + i);
        }
    }
 }

2.实现Runnable接口创建线程

（1）定义一个类实现Runnable接口，并重写该接口的run()方法 （2）创建 Runnable实现类的对象，作为创建Thread对象的target参数，此Thread对象才是真正的线程对象 （3）调用线程对象的start()方法来启动线程

public class CreateThreadTest {
public static void main(String[] args) {
    RunnableTest runnableTest = new RunnableTest();
    new Thread(runnableTest, "线程1").start();
    new Thread(runnableTest, "线程2").start();
	}
}
class RunnableTest implements Runnable{
private int i = 0;
@Override
public void run() {
    for (; i < 100; i++) {
        System.out.println(Thread.currentThread().getName()  + " is running: " + i);
    }
}
    }

3.使用Callable和Future创建线程

和Runnable接口不一样，Callable接口提供了一个call()方法作为线程执行体，call()方法比run()方法功能要强大：call()方法可以有返回值，可以声明抛出异常。

public interface Callable {
    V call() throws Exception;
}

Java5提供了Future接口来接收Callable接口中call()方法的返回值。 Callable接口是 Java5 新增的接口，不是Runnable接口的子接口，所以Callable对象不能直接作为Thread对象的target。针对这个问题，引入了RunnableFuture接口，RunnableFuture接口是Runnable接口和Future接口的子接口，可以作为Thread对象的target 。同时，Java5提供了一个RunnableFuture接口的实现类：FutureTask ，FutureTask可以作为Thread对象的target。

介绍了相关概念之后，使用Callable和Future创建线程的步骤如下： （1）定义一个类实现Callable接口，并重写call()方法，该call()方法将作为线程执行体，并且有返回值 （2）创建Callable实现类的实例，使用FutureTask类来包装Callable对象 （3）使用FutureTask对象作为Thread对象的target创建并启动线程 （4）调用FutureTask对象的get()方法来获得子线程执行结束后的返回值

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;
public class CreateThreadTest {
public static void main(String[] args) {
	CallableTest callableTest = new CallableTest();
	FutureTask futureTask = new FutureTask<>(callableTest);
	new Thread(futureTask).start();
	try {
		System.out.println("子线程的返回值: " + futureTask.get());
	} catch (InterruptedException e) {
		e.printStackTrace();
	} catch (ExecutionException e) {
		e.printStackTrace();
	}
}
}
class CallableTest implements Callable{
@Override
public Integer call() throws Exception {
    int sum = 0;
    for (int i = 1; i < 101; i++) {
        sum += i;
    }
    System.out.println(Thread.currentThread().getName() + " is running: " + sum);
    return sum;
}
}

创建线程的三种方式的对比  可以看下