多线程

• 说起进程，先了解程序是指令和数据的有序集合，其本身没有任何意义，是一个静态的概念。
• 而进程则是执行程序的一次执行过程，它是一个动态概念。是系统分配资源的单位。
• 通常在一个进程中可以包含若干个线程，当然一个进程至少有一个线程，不然没有存在意义。线程是CPU调度和执行的单位。
  注：很多多线程是模拟出来的，真正的多线程是指多个CPU，即多核，如服务器。如果是模拟出来的多线程，即在一个CPU的情况下，在同一时间点，CPU只能执行一个代码，因为切换的很快，所以就有同步执行的错觉。

继承Thead（启动：子类对象.start,oop单继承局限性）

public class TheadTest extends Thread{
    @Override
    public void run() {
        System.out.println("线程实现方式：继承thead");
    }
    public static void main(String[] args) {
        TheadTest thead1 = new TheadTest();
        TheadTest thead2 = new TheadTest();
        TheadTest thead3 = new TheadTest();
        thead1.start();
        thead2.start();
        thead3.start();
    }
}

实现Runnable（启动：将对象出入Thead.start,更加灵活，便于一个资源对象被多线程使用）

public class RunnableTest implements Runnable {
    @Override
    public void run() {
        System.out.println("实现线程方式：实现Runnable"+"==="+Thread.currentThread().getName());
    }
    public static void main(String[] args) {
        RunnableTest runnable = new RunnableTest();
        new Thread(runnable,"线程a").start();
        new Thread(runnable,"线程b").start();
        new Thread(runnable,"线程c").start();
    }
}

实现Callable接口(重写的call有返回值，并抛出异常)

import java.util.concurrent.*;
public class CallableTest implements Callable<Boolean> {
    @Override
    public Boolean call() throws Exception {
        System.out.println("实现线程方式：实现Callable"+"==="+Thread.currentThread().getName());
        return true;
    }
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        CallableTest callable1 = new CallableTest();
        CallableTest callable2 = new CallableTest();
        CallableTest callable3 = new CallableTest();
        //创建执行服务
        ExecutorService ser = Executors.newFixedThreadPool(3);
        //提交执行
        Future<Boolean> submit1 = ser.submit(callable1);
        Future<Boolean> submit2 = ser.submit(callable2);
        Future<Boolean> submit3 = ser.submit(callable3);
        //获取结果
        Boolean rs1 = submit1.get();
        Boolean rs2 = submit1.get();
        Boolean rs3 = submit1.get();
        //关闭服务
        ser.shutdown();
    }
}

多线程实现同步，可以采用synchronized关键字和lock重入锁解决

synchronized方法控制对对象的访问，每个对象对应一把锁，每个synchronized方法都必须获得调用该方法的对象的锁才能执行，否则线程阻塞。

自从Java 1.5之后，在java.util.concurrent包下提供了若干个阻塞队列，或Redis消息队列等来实现同步等，简单介绍下lock锁

import java.util.concurrent.locks.ReentrantLock;
public class LockTest {
    public static void main(String[] args) {
        CellTicket cellTicket = new CellTicket();
        new Thread(cellTicket,"小张").start();
        new Thread(cellTicket,"小花").start();
        new Thread(cellTicket,"小黑").start();
    }
}
class CellTicket implements Runnable {
    private int ticketNum=10;
    //定义锁
    private final ReentrantLock lock = new ReentrantLock();
    @Override
    public void run() {
        while (true){
            lock.lock();//加锁
            try {
                if(ticketNum>0){
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println("票数："+ticketNum--);
                }else {
                    break;
                }
            }finally {
                lock.unlock();//释放锁
            }
        }
    }
}