进程（process）与线程(thread)区别和线程的三种实现方法

一、线程和进程区别

说起进程，就不得不说下程序。程序是指令和数据的集合，其本身没有任何运行的含义，是一个静态的概念。

而进程则是执行程序的一次执行过程，它是一个动态的概念。是系统资源分配的单位。

通常在一个进程中可以包含若干个线程，当然一个进程中至少有一个线程，不然没有存在的意义。线程是cpu调度和执行的单位。

注意：很多多线程是模拟出来的，真正的多线程是指有多个cpu，即多核，如服务器。如果是模拟出来的多线程，即在一个cpu的情况下，在同一个时间点，cpu只能执行一个代码，因为切换的很快，所以就有同时执行的错局。

二、普通方法调用和多线程
 

 三、三种实现线程的方法

 1、继承Thread类，重写run()方法，创建线程对象，调用start()方法启动线程

 2、实现Runnable接口，实现run()方法，创建接口实现类对象，创建thread代理对象并将实现类对象传入thread代理对象做参数，thread代理类对象调用start()方法启动线程

举例龟兔赛跑

public class TestRunnable implements Runnable{

    private String winner;

    @Override
    public void run() {
        for (int i = 0; i <= 10; i++) {
            boolean flag = isComplete(i);
            if (flag) {
                break;
            }
            System.out.println( Thread.currentThread().getName() + "---> 已经跑了" + i +"步");

        }
    }

    public boolean isComplete(int steps){
        if (winner != null) {
            return true;
        }
            if (steps >= 10){
                winner = Thread.currentThread().getName();
                System.out.println("winner is " + this.winner);
                return true;
            }

        return false;
    }

    public static void main(String[] args) {
        //这里只new了一个TestRunnable()对象，所以里面的winner变量是共享的。
        TestRunnable runnable = new TestRunnable();
        new Thread(runnable, "兔子").start();
        new Thread(runnable, "乌龟").start();
    }
}

 执行结果（不一定谁赢，因为线程交替执行）

3、实现Callable接口

 举例龟兔赛跑

import java.util.concurrent.*;

public class TestCallable implements Callable<String> {

    /**
     * 注意：这里如果不加static，那么winner这个变量不是对象共享的，每个new TestCallable对象都会有自己的winner，
     * 只有加了static才使得下面代码new TestCallable("兔子")和new TestCallable("乌龟")对象共享一个winner变量
     * 才符合我们原本的用意。不然两个线程都是各自跑各自的，互不干扰。
     */
    private static String winner;
    private String name;

    public TestCallable(String name){
        this.name = name;
    }

    @Override
    public String call() throws Exception {
        for (int i = 0; i <= 10; i++) {
            boolean flag = isComplete(i);
            if (flag) {
                break;
            }
            System.out.println(name + "---> 已经跑了" + i + "步");
        }
        return winner;
    }

    public boolean isComplete(int steps) {
        if (winner != null) {
            return true;
        }
        if (steps >= 10) {
            winner = name;
            System.out.println("赢家是 " + name);
            return true;
        }
        return false;
    }

    public static void main(String[] args) throws ExecutionException, InterruptedException {
        //创建执行服务
        ExecutorService executorService = Executors.newFixedThreadPool(2);
        //提交执行
        //需要注意的是这里new了两个对象，所以需要在winner上加static，让其成为类级别的共享状态
        Future<String> future1 = executorService.submit(new TestCallable("兔子"));
        Future<String> future2 = executorService.submit(new TestCallable("乌龟"));

        //获取返回结果
        String result1 = future1.get();
        String result2 = future2.get();

        System.out.println("Result 1: " + result1);
        System.out.println("Result 2: " + result2);

        executorService.shutdown();
    }
}

  执行结果（不一定谁赢，因为线程交替执行）

 题外：假设我们把  private static String winner 中的static去掉，看看结果如何？（各自执行，互不干扰）