JAVA并发

一、什么是并发

在操作系统中的并发，是指一个时间段中有几个程序都处于已启动运行到运行完毕之间，且这几个程序都是在同一个处理机上运行，但任一个时刻点上只有一个程序在处理机上运行。

二、为什么需要并发

• 提高CPU的使用效率
• 降低系统的响应时间
• 提升系统的容错率

三、并发操作(JUC)

线程的使用

1.实现Runnable接口

public class TestRunnable implements Runnable{
	@Override
    public void run(){
    	//...
    }
     //使用Runnable实例在创建一个Thread实例，调用Thread的实例的start()方法启动线程
    public static void main(String[] args){
    	TestRunnable tr = new TestRunnable();
    	Thread thread = new Thread(tr);
    	thread.start();
    }
}

2.继承Thread类

public class TestThread extends Thread{
    public void run(){
    	//...
    }
    //启动线程
    public static void main(String[] args){
    	TestThread tt = new TestThread();
        tt.start();
    }
}

3.实现Callable接口

public class TestCallable implements Callable{
	//返回值可以为任意引用类型值 这里举例Integer
    @Override
    public Integer run(){
    	//...
        return 123;
        
    }
     //与 Runnable 相比，Callable 可以有返回值，返回值通过 FutureTask 进行封装。
    public static void main(String[] args){
    	TestCallable tr = new TestCallable();
        //通过FutureTask封装返回结果
        FutureTask<Integer> fu = new FutureTask<>(tr);
    	Thread thread = new Thread(fu);
    	thread.start();
        System.out.println(fu.get());
    }
}

实现接口vs继承Thread

1.Java不支持多继承，但可以实现多个接口
2.类可能只要求可执行就行，继承整个Thread开销太大

线程->锁（互斥同步）

Java提供了两种锁机制来控制多个线程对共享资源的互斥访问

1. Sychronized的使用

同步代码块

public void func() {
    synchronized (this) {
        // ...
    }
}

同步方法

public synchronized void func () {
    // ...
}

同步类

public void func() {
	//同步一个类
    synchronized (SynchronizedExample.class) {
        // ...
    }
}

同步静态方法

public synchronized static void fun() {
    // ...
}

2. ReentrantLock

public class TestLock {
	//实例ReentrantLock
    private Lock lock = new ReentrantLock();
    public void func() {
        lock.lock();
        try {
            for (int i = 0; i < 10; i++) {
                System.out.print(i + " ");
            }
        } finally {
            lock.unlock(); // 确保释放锁，从而避免发生死锁。
        }
    }
}

两者比较

1. 锁的实现：前者为JVM实现，后者为JDK的API
2. 性能：Java的新版本对Sychronized进行了优化，例如自旋锁，两者大致相同
3. 等待可中断：在当前拥有锁的线程不释放锁时，后者可以放弃等待，而前者不可以
4. 公平锁：前者为非公平锁，后者可公平可不公平

使用选择：若要使用ReentrantLock的高级功能可优先选择，否则优先使用Sychronized，因为前者是原生JVM实现的，不管Java的哪个版本都会支持。并且使用Sychronized不用管锁的释放情况，也就不用担心产生死锁的情况

线程->状态

• 新建（New）：创建后线程尚未启动
• 可运行（Runnable）：可以被运行，具体有没运行看底层操作系统的调度
• 阻塞（Bolcked）：获取资源时有其他线程占用该资源，则进入阻塞状态
• 无限期等待：等待其它线程显式地唤醒。
• 限期等待：无需等待其它线程显式地唤醒，在一定时间之后会被系统自动唤醒。
• 死亡：可以是线程结束任务之后自己结束，或者产生了异常而结束。
  Java SE 9 Enum Thread.State