【线程学习笔记】

什么是线程？
线程是操作系统能够进行运算调度的最小单位。它被包含在进程之中，
是进程中的实际运作单位。

在多核CPU中，利用多线程可以实现真正意义上的并行执行

在一个应用进程中，会存在多个同时执行的任务，如果其中一个任务
被阻塞，将会引起不依赖该任务的任务也被阻塞。通过对不同任务创
建不同的线程去处理，可以提升程序处理的实时性。

首先先看线程的创建方式，大家一定背的可熟儿了（继承thread，实现runnable，实现callable，线程池），建议还是手打一遍。

1.Thread创建

public class ThreadDemo extends Thread{
    @Override
    public void run() {
        System.out.println("线程名称"+Thread.currentThread().getName());
    }

    public static void main(String[] args) {
        ThreadDemo threadDemo = new ThreadDemo();
        threadDemo.start();
    }
}

执行结果为

2.Runnable创建

public class RunnableDome implements Runnable{

    @Override
    public void run() {
        System.out.println("线程名称"+Thread.currentThread().getName());
    }

    public static void main(String[] args) {
        RunnableDome runnableDome = new RunnableDome();
        Thread thread = new Thread(runnableDome);
        thread.start();

    }
}

执行结果为

3.Callable创建

public class CallableDome implements Callable<String> {
    @Override
    public String call() throws Exception {
        System.out.println("线程名称"+Thread.currentThread().getName());
        return "hello";
    }

    public static void main(String[] args) throws ExecutionException, InterruptedException {
        ExecutorService executorService = Executors.newFixedThreadPool(1);
        Future<String> submit = executorService.submit(new CallableDome());
        System.out.println(submit.get());
    }
}

运行结果

眼睛尖的就会发现，call方法与之前的两个相比，会在线程结束后返回一个值。

之前说了线程是并行执行的，那么就可能出现一些问题，比如

public class ThreadJoinDemo{
    private static int x =0;
    private static int i =0;
    public static void main(String[] args) throws InterruptedException {
        for (int k=1;k<10;k++){
        Thread t1 = new Thread(() -> {
            i = 1;
            x = 2;
        });
        Thread t2 = new Thread(() -> {
           i=x+2;
        });
            t1.start();
            t2.start();
            System.out.println("i的结果是"+i);
        }
    }
}

结果是这样的

public class ThreadJoinDemo{
    private static int x =0;
    private static int i =0;
    public static void main(String[] args) throws InterruptedException {
        for (int k=1;k<10;k++){
        Thread t1 = new Thread(() -> {
            i = 1;
            x = 2;
        });
        Thread t2 = new Thread(() -> {
           i=x+2;
        });
            t1.start();
            //join方法使得t1执行结果对t2和主线程可见
            t1.join();
            t2.start();
            System.out.println("i的结果是"+i);
        }
    }
}

我们加上join方法阻塞一下看看结果

结果竟然有两种。

public class ThreadJoinDemo{
    private static int x =0;
    private static int i =0;
    public static void main(String[] args) throws InterruptedException {
        for (int k=1;k<10;k++){
        Thread t1 = new Thread(() -> {
            i = 1;
            x = 2;
        });
        Thread t2 = new Thread(() -> {
           i=x+2;
        });
            t1.start();
            //join方法使得t1执行结果对t2和主线程可见
            t1.join();
            t2.start();
            //join方法使得t2执行结果对主线程可见
            t2.join();
            System.out.println("i的结果是"+i);
        }
    }
}

这结果就正常了

因为本人学艺不精，找人问了问为什么会出现这种情况

第一种情况：
主线程跑的太快了，溜了溜了，其他还没反应过来，主线程结束了。。
第二种情况：
t1的结果这时候对t2和main线程都是可见的，但t2对主线程不一定是可见的，所以main线程的System.out.println(i)仍然会出现1的情况。
第三种情况：
t2的结果对main线程就是可见的了，此时i就是4了。