并发编程系列（一）

线程和进程的概念：
  线程是CPU执行的基本单位，是进程运行的独立单元。
  进程是操作系统执行的基本单位，每个线程都是每个进程的一次执行，每个进程中可以有多个线程，每个进程都会有一个独立的内存空间。
举一个例子说明一下进程和线程：QQ和人聊天和人视屏就是一个进程和两个线程。
进程和线程的区别：
进程：有独立的内存空间，堆栈内存空间是独立的，每个进程必须有一个线程。
线程：栈内存空间共享（堆内存空间共享），线程消耗资源小。
创建多线程：
一共四种方式：
给个图更能理解多线程的关系：

实现线程第一种方式继承Thread类：

public class Demo1Thread extends Thread{
@Override
public void run() {
    System.out.println("继承Thread,实现多线程");
}

public static void main(String[] args) {
    Demo1Thread thread = new Demo1Thread();

    thread.start();//开启线程，这里的开始线程不一定就执行了，只是等待被CPU调度


}

}
实现线程的第二种方法实现Runnable接口：

public class Demo2Runnable implements Runnable{

    @Override
    public void run() {
        System.out.println("实现Runnable接口实现多线程");
    }

    public static void main(String[] args) {
        Demo2Runnable runnable = new Demo2Runnable();
        Thread thread = new Thread(runnable);

        thread.start();

    }
}
匿名内部类实现：
public class Demo2Runnable{


    public static void main(String[] args) {
        new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("匿名内部类实现Runnable接口，实现多线程");
            }
        }).start();


    }
}

实现线程的第三种方法实现Callable接口实现多线程：（和第二种方式的区别就是实现callable有返回值，而实现runnable没有返回值）

public class Demo3Callable implements Callable {

    @Override
    public String call() throws Exception {
        return "我是callable方法实现的多线程";
    }

    public static void main(String[] args) throws Exception {
        Demo3Callable callable = new Demo3Callable();
        FutureTask<String> target = new FutureTask<String>(callable);
        new Thread(target).start();
        
        //这个是直接这个类获取的值
        String call = callable.call();
        
        //futureTask获取执行的值
        String s = target.get();
        System.out.println(call);
        System.out.println(s+"------");

    }
}

第四中方式线程池实现多线程：

public class ThreedPoolDemo implements Runnable{

    @Override
    public void run() {
        System.out.println("我是实现runnable接口然后使用线程池实现多线程");
    }

    public static void main(String[] args) {
        ExecutorService executorService = Executors.newFixedThreadPool(3);

        FutureTask<String> task = new FutureTask<>(new ThreadDemo());
        //executorService.execute(new ThreedPoolDemo());
        try {
            executorService.execute(task);
            String s = task.get();
            System.out.println(s);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
        executorService.shutdown();

    }
    static class ThreadDemo implements Callable<String>{
        @Override
        public String call() throws Exception {
            return "我是首先实现Callable方法的多线程";
        }
    }
}

  其实把上面的图记住就很能明白，四种线程的实现方式。