JUC学习-1 进程与线程、Lock

进程与线程

进程是操作系统资源分配的基本单位； 线程是任务调度和执行的基本单位。

（1）进程

进程是程序的一次执行过程，是一个动态概念，是程序在执行过程中分配和管理资源的基本单位，每一个进程都有一个自己的地址空间，至少有 5 种基本状态，它们是：初始态，执行态，等待状态，就绪状态，终止状态。

（2）线程

线程是CPU调度和分派的基本单位，它可与同属一个进程的其他的线程共享进程所拥有的全部资源。

（3）联系

线程是进程的一部分，一个线程只能属于一个进程，而一个进程可以有多个线程，但至少有一个线程。

（4）区别：理解它们的差别，我从资源使用的角度出发。（所谓的资源就是计算机里的中央处理器，内存，文件，网络等等）

根本区别：进程是操作系统资源分配的基本单位，而线程是任务调度和执行的基本单位

在开销方面：每个进程都有独立的代码和数据空间（程序上下文），程序之间的切换会有较大的开销；线程可以看做轻量级的进程，同一类线程共享代码和数据空间，每个线程都有自己独立的运行栈和程序计数器（PC），线程之间切换的开销小。

所处环境：在操作系统中能同时运行多个进程（程序）；而在同一个进程（程序）中有多个线程同时执行（通过CPU调度，在每个时间片中只有一个线程执行）

内存分配方面：系统在运行的时候会为每个进程分配不同的内存空间；而对线程而言，除了CPU外，系统不会为线程分配内存（线程所使用的资源来自其所属进程的资源），线程组之间只能共享资源。

包含关系：没有线程的进程可以看做是单线程的，如果一个进程内有多个线程，则执行过程不是一条线的，而是多条线（线程）共同完成的；线程是进程的一部分，所以线程也被称为轻权进程或者轻量级进程。

其他：

并发的目的： 充分利用CPU资源

多进程的方式也可以实现并发，为什么我们要使用多线程?

• 进程间的通信比较复杂，而线程间的通信比较简单，通常情况下，我们需要使用共享资源，这些资源在线程间的通信比较容易。
• 进程是重量级的，而线程是轻量级的，故多线程方式的系统开销更小。

参考：

• 每个程序员都会遇到的面试问题：谈谈进程和线程的区别
• 进程与线程的基本概念

---

线程状态

public enum State {
        //新生
        NEW,
        //运行
        RUNNABLE,
        //阻塞
        BLOCKED,
        // 等待
        WAITING,
        //超时等待
        TIMED_WAITING,
        //终止
        TERMINATED;
    }

wait与sleep区别

来自的类
从使用角度看，sleep是Thread线程类的方法，而wait是Object顶级类的方法。

使用范围
sleep可以在任何地方使用，而wait只能在同步方法或者同步块中使用。

CPU及资源锁释放
sleep,wait调用后都会暂停当前线程并让出cpu的执行时间，但不同的是sleep不会释放当前持有的对象的锁资源，到时间后会继续执行，而wait会放弃所有锁并需要notify/notifyAll后重新获取到对象锁资源后才能继续执行。

异常捕获
sleep需要捕获或者抛出异常，而wait/notify/notifyAll不需要。

---

Lock锁（重点）

synchronized与Lock的区别

并发集合

CopyOnWriteArraySet、CopyOnWriteArrayList、ConcurrentHashMap

三种使用线程的方式

1、extends Thread
	class ThreadTest extends Thread{
	    //重写run方法
	    @Override
	    public void run() {
	        System.out.println();
	    }
	}
	//使用
        new ThreadTest().start();

2、implements Runnable
	class ThreadTest implements Runnable{
	    //重写run方法
	    @Override
	    public void run() {
	        System.out.println();
	    }
	}
	//使用
        new Thread(new ThreadTest()).start();
       或者直接使用lambda表达式方法
       new Thread(() -> {
            System.out.println();
        }).start();
3、implements Callable
	class ThreadTest implements Callable<Integer> {
	    //重写call方法
	    @Override
	    public Integer call() throws Exception {
	        return 0;
	    }
	}
	//使用
        FutureTask<Integer> futureTask = new FutureTask<Integer>(new ThreadTest());
        new Thread(futureTask,"A").start();
        new Thread(futureTask,"B").start();//结果会被缓存，效率高，只打印一个call
        System.out.println(futureTask.get()); //这个get方法可能会产生阻塞
        //打印结果 A : call 
        //打印结果 0

常用的辅助类

• CountDownLatch 减法计数

public class CountDownLatchDemo {
    public static void main(String[] args) throws InterruptedException {
        // 计数器，必须要执行任务时使用
        CountDownLatch count = new CountDownLatch(6);
        for (int i = 0; i < 6; i++) {
            new Thread(() -> {
                System.out.println(Thread.currentThread().getName()+" Go out");
                count.countDown();//-1
            }).start();
        }
        count.await();//等待计数器归零，然后再向下执行
        System.out.println("Close the door");
    }
}

• CyclicBarrier 加法计数

public class CyclicBarrierDemo {
    public static void main(String[] args) {
        CyclicBarrier barrier = new CyclicBarrier(7,() -> {
            System.out.println("召唤神龙");
        });
        for (int i = 1; i <= 7; i++) {
            final int temp = i ;
            new Thread(() -> {
                System.out.println(Thread.currentThread().getName()+" : 集齐"+temp+"颗龙珠");
                try {
                    barrier.await();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } catch (BrokenBarrierException e) {
                    e.printStackTrace();
                }
            }).start();
        }
    }
}

• Semaphore 并发数限流

public class SemaphoreDemo {
    public static void main(String[] args) {
        //作用：多个共享资源互斥使用！并发限流，控制最大的线程数
        Semaphore semaphore = new Semaphore(3);
        for (int i = 0; i < 6; i++) {
            new Thread(() -> {
                //acquire() 得到
                try {
                    semaphore.acquire();//获得，如果已经满了，等待被释放空出
                    System.out.println(Thread.currentThread().getName()+"抢到车位");
                    TimeUnit.SECONDS.sleep(2);
                    System.out.println(Thread.currentThread().getName()+"离开车位");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }finally {
                    //释放
                    semaphore.release();//释放，会将当前信号量释放+1，然后唤醒等待的线程
                }
            },String.valueOf(i)).start();
        }
    }
}