java并发编程学习笔记1

1.什么是JUC

juc即java.util.concurrent
普通的线程代码类 Thread
Runnable：没有返回值，效率相比callable相对较低
Lock所有已知实现类：
ReentrantLock 可重入锁(常用)
ReentrantReadWriteLock.ReadLock 读锁
ReentrantReadWriteLock.WriteLock 写锁

2.进程和线程

进程即一个程序的一次执行过程
一个进程往往包含多个线程，至少一个线程
java默认有两个线程：main线程和gc线程
java线程相关Thread、Runnable、Callable
并发、并行
并发：多个线程操作同一个资源
cpu一核，模拟出来多个线程
并行：cpu多核，多个线程可以同时执行
并发编程的本质是：充分利用cpu资源
线程状态：NEW新生状态、RUNNABLE运行状态、BLOCKED阻塞状态、WAITING等待状态、TIMED_WAITING超时等待状态、TERMINATED终止状态
wait与sleep的区别
1、来自不同的类
Object–>wait
Thread–>sleep
2、关于锁的释放
wait释放锁、sleep不会释放锁
3、使用范围不同
wait必须在同步代码块中
sleep可以在任何地方

3.Lock锁

多线程小例子(synchronized)

package jug;
public class TestSale {
    public static void main(String[] args) {
        Ticket ticket=new Ticket();
        //Lambda表达式
        new Thread(()->{
            for (int i = 0; i < 20; i++) {
                ticket.sale();
            }
            },"A").start();
        new Thread(()->{
            for (int i = 0; i < 20; i++) {
                ticket.sale();
            }
        },"B").start();
        new Thread(()->{
            for (int i = 0; i < 20; i++) {
                ticket.sale();
            }
        },"C").start();
    }
}
//实际的多线程开发,线程就是一个单独的资源类，没有附加操作
class Ticket{
    private int num=30;
    public synchronized void sale(){
        if(num>0)
        {
            System.out.println(Thread.currentThread().getName()+"卖出了1张票，剩余"+--num+"张");
        }
    }
}

Lock接口
Lock锁使用方法

Lock l = ...; l.lock(); try { 
// access the resource protected by this lock }
finally { l.unlock(); } 

当在不同范围内发生锁定和解锁时，必须注意确保在锁定时执行的所有代码由try-finally或try-catch保护，以确保在必要时释放锁定。

所有已知实现类：
ReentrantLock 可重入锁，常用
ReentrantReadWriteLock.ReadLock 读锁
ReentrantReadWriteLock.WriteLock 写锁

多线程小例子(Lock)

package jug;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class TestSale {
    public static void main(String[] args) {
        Ticket ticket=new Ticket();
        //Lambda表达式
        new Thread(()->{
            for (int i = 0; i < 20; i++) {
                ticket.sale();
            }
            },"A").start();
        new Thread(()->{
            for (int i = 0; i < 20; i++) {
                ticket.sale();
            }
        },"B").start();
        new Thread(()->{
            for (int i = 0; i < 20; i++) {
                ticket.sale();
            }
        },"C").start();
    }
}
//实际的多线程开发,线程就是一个单独的资源类，没有附加操作
class Ticket{
    private int num=30;
    Lock lock=new ReentrantLock();
    public void sale(){
        lock.lock();//加锁
        try {
            if (num > 0) {
                System.out.println(Thread.currentThread().getName() + "卖出了1张票，剩余" + --num + "张");
            }
        }catch (Exception e)
        {e.printStackTrace();}
        finally {
            lock.unlock();//解锁
        }
    }
}

Lock三步曲
1、new ReentrantLock
2、l.lock()加锁
3、finally l.unlock()解锁

synchronized和Lock的区别
1、synchronized是java关键字，Lock是一个java类
2、synchronized无法判断锁的状态，Lock可以判断是否获取了锁
3、synchronized会自动释放锁，Lock必须手动释放锁，如果不释放，容易造成死锁
4、synchronized的线程拿不到资源时，会一直等待资源的释放，但Lock锁的线程不一定会等待下去
5、synchronized可重入锁，不可以中断，非公平锁；Lock可重入锁，可以判断是否获得锁，非公平锁(可以自己设置)
6、synchronized适合锁少量的代码同步问题，Lock适合锁大量的同步代码

4.生产者和消费者问题

生产者和消费者问题(synchronized)

package jug;
//生产者，消费者
public class PC {
    public static void main(String[] args) {
        Data data=new Data();
        new Thread(()->{
            for (int i = 0; i < 20; i++) {
                data.increment();
            }
        },"A").start();
        new Thread(()->{
            for (int i = 0; i < 20; i++) {
                data.decrement();
            }
        },"B").start();
        new Thread(()->{
            for (int i = 0; i < 20; i++) {
                data.increment();
            }
        },"C").start();
        new Thread(()->{
            for (int i = 0; i < 20; i++) {
                data.decrement();
            }
        },"D").start();
    }
}
class Data{
    private int num=0;
    public synchronized void increment()  {
        while(num!=0)
        {
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        num++;
        System.out.println(Thread.currentThread().getName()+num);
        //生产完成通知消费者消费
        this.notifyAll();
    }
    public synchronized void decrement()  {
        while(num==0)
        {
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        num--;
        System.out.println(Thread.currentThread().getName()+num);
        //消费完成，通知生产者生产
        this.notifyAll();
    }
}

面试热点：生产者消费者、单例模式、排序算法、死锁

在多线程中使用if判断，容易造成虚假唤醒，因而使用while判断避免虚假唤醒问题
参考博客：https://www.cnblogs.com/tqyysm/articles/9765667.html

生产者消费者问题(Lock)

package jug;

import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

//生产者，消费者
public class PC {
    public static void main(String[] args) {
        Data data=new Data();
        new Thread(()->{
            for (int i = 0; i < 20; i++) {
                data.increment();
            }
        },"A").start();
        new Thread(()->{
            for (int i = 0; i < 20; i++) {
                data.decrement();
            }
        },"B").start();
        new Thread(()->{
            for (int i = 0; i < 20; i++) {
                data.increment();
            }
        },"C").start();
        new Thread(()->{
            for (int i = 0; i < 20; i++) {
                data.decrement();
            }
        },"D").start();
    }
}
class Data{
    private int num=0;
    Lock lock=new ReentrantLock();
    Condition condition=lock.newCondition();
    public  void increment()  {
        lock.lock();
        try {
        while(num!=0)
        {
                //等待消费者消费
                condition.await();
        }
        num++;
        System.out.println(Thread.currentThread().getName()+num);
        //生产完成通知消费者消费
        condition.signalAll();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }finally {
            lock.unlock();
        }
    }
    public  void decrement()  {
        lock.lock();
        try {
            while(num==0)
            {
                condition.await();
            }
            num--;
            System.out.println(Thread.currentThread().getName()+num);
            //消费完成，通知生产者生产
            condition.signalAll();
        }catch (InterruptedException e) {
        e.printStackTrace();
    }finally {
            lock.unlock();
        }
}

    }