JUC并发编程

进程：系统中正在运行的一个应用程序，程序一旦运行就是进程，是资源分配的最小单元。

线程：系统分配处理器时间资源的基本单元，进程之内独立执行的一个单元执行流，是程序执行的最小单位。

Lock

需要手动上锁和释放锁，synchronized是自动的，Lock操作不当就会出现死锁的问题。

import java.util.concurrent.locks.ReentrantLock;// 创建资源类，定义属性和操作方法
class LTicket {private int number = 30;// 创建可重入锁private final ReentrantLock lock = new ReentrantLock();public void sale(){// 上锁lock.lock();// 判断是否有票可卖try {if (number>0) {System.out.println(Thread.currentThread().getName()+": 卖出"+number--+"剩余"+number+"张票");}} finally {// 解锁，如果线程出现了以上就不能释放锁，其他的线程就无法正常执行了lock.unlock();}}
}
public class LSaleTicket {// 创建多个线程，调用资源类的操作方法// 创建三个线程public static void main(String[] args) {LTicket ticket = new LTicket();new Thread(() -> {for (int i=0;i<40;i++){ticket.sale();}},"A").start();new Thread(() -> {for (int i=0;i<40;i++){ticket.sale();}},"B").start();new Thread(() -> {for (int i=0;i<40;i++){ticket.sale();}},"C").start();}
}

1. Lock是一个接口，而synchronized是Java的关键字，synchronized是内置的语言实现

2. sync在发生异常时会自动释放线程占有的锁，不会导致死锁现象发生，而Lock在发生异常时如果没有主动通过unLock()释放锁，则很可能造成死锁现象，使用Lock时需要再finally中释放锁

3. Lock可以让等待锁的线程响应中断，而synchronized不行，使用synchronized等待的线程会一直等待下去

4. 通过Lock可以知道是否成功获取锁，而synchronized无法办到

5. Lock可以提高多个线程进行读操作的效率

多线程编程步骤

1. 创建资源类，在资源类创建属性和操作方法

2. 在资源类操作方法

   1. 判断

   2. 执行

   3. 通知

3. 创建多个线程，调用资源类的操作方法

4. 判断需要加入到while循环中

线程间的通信

// 线程间的通信 notify()
class Share {private int number = 0;// 一个线程+1，另一个线程-1，保持为0public synchronized void incr() throws InterruptedException {// 判断
//        if (number!=0){
//            this.wait();// 在哪里睡就会在哪里唤醒，不会重新执行操作
//        }// 如果有更多的线程，就需要把wait()放在while循环中while (number!=0){this.wait();}number++;// 通知System.out.println(Thread.currentThread().getName()+"::"+number);this.notifyAll();// 唤醒其他所有等待过程中的线程，表示操作完成了}public synchronized void decr() throws InterruptedException {
//        if (number==0){
//            this.wait();
//        }while (number==0){this.wait();}number--;System.out.println(Thread.currentThread().getName()+"::"+number);this.notifyAll();}
}
public class ThreadDemo1 {public static void main(String[] args) {Share s = new Share();new Thread(()->{for (int i=1;i<=10;i++){try {s.incr();} catch (InterruptedException e) {e.printStackTrace();}}},"AA").start();new Thread(() -> {for (int i=1;i<=10;i++){try {s.decr();} catch (InterruptedException e) {e.printStackTrace();}}},"BB").start();new Thread(()->{for (int i=1;i<=10;i++){try {s.incr();} catch (InterruptedException e) {e.printStackTrace();}}},"CC").start();new Thread(() -> {for (int i=1;i<=10;i++){try {s.decr();} catch (InterruptedException e) {e.printStackTrace();}}},"DD").start();}
}

import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;class LShare{private int number = 0;// 创建LOCK对象,可重入锁private Lock lock = new ReentrantLock();// 这个是做什么的？？？？private Condition condition = lock.newCondition();public void incr() throws InterruptedException {lock.lock();try {while (number!=0){condition.await();//等待}number++;System.out.println(Thread.currentThread().getName()+"::"+number);condition.signalAll();}finally {lock.unlock();}}public void decr() throws InterruptedException {lock.lock();try {while (number==0){condition.await();}number--;System.out.println(Thread.currentThread().getName()+"::"+number);condition.signalAll();}finally {lock.unlock();}}}
public class LThreadDemo {public static void main(String[] args) {LShare share = new LShare();new Thread(()->{for (int i=0;i<10;i++){try {share.incr();} catch (InterruptedException e) {e.printStackTrace();}}},"AA").start();new Thread(()->{for (int i=0;i<10;i++){try {share.decr();} catch (InterruptedException e) {e.printStackTrace();}}},"BB").start();new Thread(()->{for (int i=0;i<10;i++){try {share.incr();} catch (InterruptedException e) {e.printStackTrace();}}},"CC").start();new Thread(()->{for (int i=0;i<10;i++){try {share.decr();} catch (InterruptedException e) {e.printStackTrace();}}},"DD").start();}
}

线程间的定制化通信

指定线程操作的顺序。

import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;// 创建资源类
class ShareResource {// 定义标志位private int flag = 1;// 创建LOCK锁private Lock lock = new ReentrantLock();private Condition c1 = lock.newCondition();private Condition c2 = lock.newCondition();private Condition c3 = lock.newCondition();// 打印5次,参数第几轮public void print5(int loop) throws InterruptedException {lock.lock();try {// 判断while (flag!=1){c1.await();}// 操作for (int i=0;i<5;i++){System.out.println(Thread.currentThread().getName()+"::"+i+", 轮数："+loop);}// 通知flag=2;// 修改标志位c2.signal();// 通知BB的线程}finally {lock.unlock();}}public void print10(int loop) throws InterruptedException {lock.lock();try{while (flag!=2){c2.await();}for (int i=0;i<10;i++){System.out.println(Thread.currentThread().getName()+"::"+i+", 轮数："+loop);}flag=3;c3.signal();}finally {lock.unlock();}}public void print15(int loop) throws InterruptedException {lock.lock();try{while (flag!=3){c3.await();}for (int i=0;i<15;i++){System.out.println(Thread.currentThread().getName()+"::"+i+", 轮数："+loop);}flag=1;c1.signal();}finally {lock.unlock();}}
}
public class ThreadDemo2 {public static void main(String[] args) {ShareResource shareResource = new ShareResource();new Thread(()->{for (int i=0;i<10;i++){try {shareResource.print5(i);} catch (InterruptedException e) {e.printStackTrace();}}},"AA").start();new Thread(()->{for (int i=0;i<10;i++){try {shareResource.print10(i);} catch (InterruptedException e) {e.printStackTrace();}}},"BB").start();new Thread(()->{for (int i=0;i<10;i++){try {shareResource.print15(i);} catch (InterruptedException e) {e.printStackTrace();}}},"CC").start();}
}

集合的线程安全

List 接口的大多数实现，如 ArrayList、LinkedList 等，并不是线程安全的。这意味着多个线程同时访问和修改同一个 List 实例时，可能会导致不可预知的行为或数据不一致。

/*** List集合线程不安全*/
public class LThreadDemo2 {public static void main(String[] args) {
//        List<String> list = new ArrayList<>();
//        List<String> list = new Vector<>();// Vector是线程安全的，但是方法比较老
//        List<String> list = Collections.synchronizedList(new ArrayList<>());// 通过工具类方法使得线程安全List<String> list = new CopyOnWriteArrayList<>();//写时复制技术for (int i = 0; i < 30; i++) {new Thread(()->{// 向集合中添加内容list.add(UUID.randomUUID().toString().substring(0,5));// 从集合中获取内容System.out.println(list);}, String.valueOf(i)).start();}}
}

HashSet线程不安全---->CopyOnWriteArraySet

HashSet本质上是HashMap的键，不能重复且顺序随机

HashMap---->ConcurrentHashMap

多线程锁

synchronized实现同步的基础：Java中的每一个对象都可以作为锁。

1. 普通同步方法，锁就是当前实例对象

2. 静态同步方法，锁就是当前类的Class对象

3. 同步方法块，锁是Synchronized括号里配置的对象

公平锁和非公平锁

• 非公平锁：private Lock lock = new ReentrantLock(false)

  • 一个线程把所有操作都执行完了，线程饿死

  • 优：执行效率高

• 公平锁：new ReentrantLock(true)

  • 雨露均沾

  • 缺：效率相对低

可重入锁

synchronized（隐式）和Lock（显示）都是可重入锁。通过同一把锁可以进入代码中的各个区域。（递归锁）

// 可重入锁
public class SyncLockDemo {// 递归调用，死循环，可重入锁也是一种递归锁public synchronized void add() {add();}public static void main(String[] args) {
//        synchronized
//        Object o = new Object();
//        new Thread(()->{
//            synchronized (o) {
//                System.out.println(Thread.currentThread().getName() + "  外层");
//                synchronized (o) {
//                    System.out.println(Thread.currentThread().getName() + "  中层");
//                    synchronized (o) {
//                        System.out.println(Thread.currentThread().getName() + "  内层");
//                    }
//                }
//            }
//        },"t1").start();// LockLock lock = new ReentrantLock(true);new Thread(()->{try{lock.lock();System.out.println(Thread.currentThread().getName()+" 外层");try{lock.lock();System.out.println(Thread.currentThread().getName()+" 内层");}finally {lock.unlock();}}finally {lock.unlock();}},"t2").start();}
}

 

死锁

两个以及以上的进程在执行过程中，因为争夺资源而造成一种互相等待的现象，如果没有外力干涉，它们无法再执行下去。

产生死锁原因：

1. 系统资源不足

2. 进程运行推进顺序不合适

3. 资源分配不当

public class DeadLock {static Object a = new Object();static Object b = new Object();public static void main(String[] args) {new Thread(() -> {synchronized (a) {System.out.println(Thread.currentThread().getName()+" 持有锁A试图获取锁B");synchronized (b) {System.out.println(Thread.currentThread().getName()+"获取锁B");}}},"A").start();new Thread(() -> {synchronized (b) {System.out.println(Thread.currentThread().getName()+" 持有锁B试图获取锁A");synchronized (a) {System.out.println(Thread.currentThread().getName()+"获取锁A");}}},"B").start();}
}

验证是否死锁：

1. JPS，类似Linux中 ps -ef

2. jstackJVM自带的堆栈跟踪工具

Callable接口

Runnable创建线程时，当线程终止，无法返回线程结果，而Callable就支持此功能

// 比较Runnable和Callable两个接口的不同之处
class MyThread1 implements Runnable {@Override// 无返回值public void run() {}
}class MyThread2 implements Callable {@Override// 有返回值public Integer call() throws Exception {return 20;}
}
public class CallableDemo1 {public static void main(String[] args) throws ExecutionException, InterruptedException {// Runnable接口创建线程new Thread(new MyThread1(),"AA").start();// Callable接口创建线程FutureTask<Integer> task = new FutureTask<>(new MyThread2());// 使用lam表达式简化FutureTask<Integer> task2 = new FutureTask<>(()-> {System.out.println(Thread.currentThread().getName()+" come in callable");return 1024;});new Thread(task2,"Winnie").start();// 只要get有返回值了，子线程就算是结束了
//        System.out.println(task2.get()+" before while");while (!task2.isDone()){System.out.println("wait....");}System.out.println(task2.get());System.out.println(Thread.currentThread().getName()+" come over");// Future 原理 未来任务// 主线程不影响，单开一个线程执行某个任务，主线程也能使用子线程的资源// 主线程不受影响，开启子线程做其他的任务// 汇总一次}
}

 好像写的太长了，后面的东西再新开一篇文章吧。。。