多线程实现与JUC同步工具详解

多线程学习

概念

简述如下：

并发：指一个CPU可以异步的处理多个进程
并行：则是一个CPU同时处理多个进程
进程：程序运行的执行过程，是一个程序的实例。每个进程都有自己的虚拟地址空间和控制线程
线程：是进程的一个执行单元，是操作系统调度器(Schduler)分配处理器时间的基础单元。

一句话总结：

线程是程序执行时的最小单位，它是进程的一个执行流，是CPU调度和分派的基本单位，一个进程可以由很多个线程组成，线程间共享进程的所有资源，每个线程有自己的堆栈和局部变量。线程由CPU独立调度执行，在多CPU环境下就允许多个线程同时运行。同样多线程也可以实现并发操作，每个请求分配一个线程来处理。

Java代码实现方式

• 方式一、继承Thread类，因为Java 是单继承，继承Thread的类不能再继承其他类，并且继承Thread其本身就是执行线程，每个子线程之间相互独立，资源不共享
• 方式二、实现Runnable接口，资源共享，多个线程可以对共享数据进行操作
• 方式三、实现Callable接口通过FutureTask包装器来创建Thread线程，可以接收一个返回值
• 方式四、使用ExecutorService、Callable、Future实现有返回结果的线程

完整代码如下：

import java.util.concurrent.*;

public class Demo1 {

    /**
     * 第一种实现方式:
     * 继承Thread类创建线程
     */
    public class MyThread extends Thread{
        private int ticket = 10;
        @Override
        public void run() {
            for (int i=0;i<=10;i++){
                if(ticket>0){
                    System.out.println(Thread.currentThread().getName()+"工号 还有 "+ticket--+" 张传单需要派发");
                }else{
                    System.out.println(Thread.currentThread().getName()+"工号 的传单全部派发完了，可以下班了");
                }
            }
        }
    }

    /**
     * 第二种实现方式:
     * 实现Runnable接口创建线程
     */
    public class MyRunable implements Runnable{
        private int ticket = 10;
        @Override
        public void run() {
            for (int i=0;i<10;i++){
                //加锁互斥
                synchronized (this){
                    if(ticket>0){
                        System.out.println(Thread.currentThread().getName()+"窗口 卖出倒数第"+ticket--+"张回家车票");
                    }else {
                        System.out.println(Thread.currentThread().getName()+"窗口 车票已售罄");
                        break;
                    }
                }
            }
        }
    }

    /**
     * 第三种实现方式:
     * 实现Callable接口通过FutureTask包装器来创建Thread线程
     */
    public class MyCallRunable implements Callable<Integer>{
        @Override
        public Integer call() throws Exception {
            int sum=0;
            for (int i = 0; i <= 100; i++) {
                sum += i;
            }
            return sum;
        }
    }


    /**
     * 第四种方式：
     * 线程池的方式，使用ExecutorService、Callable、Future实现有返回结果的线程
     */
    public class OddCallRunable implements Callable<Integer>{
        @Override
        public Integer call() throws Exception {
            int sum=0;
            for (int i = 0; i <= 100; i++) {
                if(i%2 == 0)
                    sum += i;
            }
            return sum;
        }
    }
    public class EvenCallRunable implements Callable<Integer>{
        @Override
        public Integer call() throws Exception {
            int sum=0;
            for (int i = 0; i <= 100; i++) {
                if(i%2 == 1)
                    sum += i;
            }
            return sum;
        }
    }


    /**
     * 总结：
     * 方式一、继承Thread类，因为Java 是单继承，继承Thread的类不能再继承其他类，并且继承Thread 其本身就是执行线程，每个子线程之间相互独立，资源不共享
     * 方式二、实现Runnable接口，资源共享，多个线程可以对共享数据进行操作
     * 方式三、实现Callable接口通过FutureTask包装器来创建Thread线程，可以接收一个返回值
     * 方式四、使用ExecutorService、Callable、Future实现有返回结果的线程
     * @param args
     * @throws InterruptedException
     */
    public static void main(String[] args) throws InterruptedException, ExecutionException {
        System.out.println("第一种方式：");
        MyThread thread1 = new Demo1().new MyThread();
        MyThread thread2 = new Demo1().new MyThread();
        MyThread thread3 = new Demo1().new MyThread();
        thread1.start();
        thread2.start();
        thread3.start();
        Thread.sleep(1000);
        System.out.println();
        System.out.println("第二种方式，");
        MyRunable myRunable = new Demo1().new MyRunable();
        Thread threadTwo1 = new Thread(myRunable);
        Thread threadTwo2 = new Thread(myRunable);
        Thread threadTwo3 = new Thread(myRunable);
        threadTwo1.start();
        threadTwo2.start();
        threadTwo3.start();

        Thread.sleep(1000);
        System.out.println();
        System.out.println("第三种方式：");
        MyCallRunable myCallRunable = new Demo1().new MyCallRunable();
        FutureTask<Integer> futureTask = ne