yz涣
yz涣

JUC基础学习笔记

参考文献：01.尚硅谷_JUC-课程介绍_哔哩哔哩_bilibili

1.JUC概述

1.1JUC简介

juc就是java.util.concurrent工具类包的简称，这是一个处理线程的工具包，JDK1.5开始出现的。

1.2进程和线程的概念

进程：指在系统内运行的一个应用程序，程序一旦运行就是进程。进程是操作系统调度和分配的基本单位。系统会每一个进程分配独立的操作空间。

线程：线程是程序的一条执行路径，一个进程最少有一个线程。线程是cpu调度和执行的最小单位。一个进程中的多个线程共享一个单独的内存空间。

1.3并发和并行的概念

并发：指两个或多个任务在同一个时间段内发生。即在同一时间段，多个指令在一个cpu中快速轮换、交替执行，使得在宏观上多个进程在同时执行。（多个线程使用同一资源执行）

并行：指两个或多个任务在同一时刻发生（同时发生）。指同一时刻，有多个指令在cpu中同时执行。如多个人在同时做不同的事情。

1.4管程（Monitor监视器）

管程：java在称为锁，是一种同步机制，保证同一时间，只有一个线程能够访问被保护的数据或者代码。

1.5用户线程和守护线程

用户线程：自定义线程都是用户线程。

守护线程：

  • 守护线程是运行在后台的一种特殊进程。
  • 它独立于控制终端并且周期性地执行某种任务或等待处理某些发生的事件。
  • 在 Java 中垃圾回收线程就是特殊的守护线程。

如果主线程已经结束，用户线程还在执行，jvm仍然为存活状态

/**
 * @author yzh
 * @date 2023-12-25
 */

public class Dome0001 {
    public static void main(String[] args) {
        Thread t = new Thread(() -> {
            System.out.println(Thread.currentThread().getName() + "::" + Thread.currentThread().isDaemon());
            while (true) {

            }
        }, "aa");
        t.start();

        System.out.println(Thread.currentThread().getName()+"over");
    }
}

JUC基础学习笔记_第1张图片

如果没有用户线程，都为守护线程，jvm就会结束

/**
 * @author yzh
 * @date 2023-12-25
 */

public class Dome0001 {
    public static void main(String[] args) {
        Thread t = new Thread(() -> {
            System.out.println(Thread.currentThread().getName() + "::" + Thread.currentThread().isDaemon());
            while (true) {

            }
        }, "aa");
        //设置为守护线程
        t.setDaemon(true);
        t.start();

        System.out.println(Thread.currentThread().getName()+"over");
    }
}

JUC基础学习笔记_第2张图片

2.Lock接口与synchronized关键字

2.1synchronized的作用范围

  1. 修饰普通方法：作用于当前对象实例，进入同步代码前要获得当前对象实例的锁
  2. 修饰静态方法：作用于当前类，进入同步代码前要获得当前类对象的锁，synchronized关键字加到static 静态方法和 synchronized(class)代码块上都是是给 Class 类上锁
  3. 修饰代码块：指定加锁对象，对给定对象加锁，进入同步代码库前要获得给定对象的锁

2.2synchronized实现卖票例子

/**
 * @author yzh
 * @date 2023-12-25
 */

/**
 * 例子：50张票，三个售票员卖票
 * 第一步：创建资源类，在资源类中创建属性和操作方法
 * 第二步：创建多个线程，调用资源类的操作方法
 *
 */
public class Dome0002 {
    public static void main(String[] args) {
        //第二步：创建多个线程，调用资源类的操作方法
        //创建Sale对象
        Sale sale = new Sale();
        //创建三个线程
        Thread t1 = new Thread(new Runnable() {
            @Override
            public void run() {
                //调用资源类的操作方法
                for (int i = 0; i < 50; i++) {
                    sale.saleTicket();
                }
            }
        }, "aa");

        Thread t2 = new Thread(new Runnable() {
            @Override
            public void run() {
                //调用资源类的操作方法
                for (int i = 0; i < 50; i++) {
                    sale.saleTicket();
                }
            }
        }, "bb");

        Thread t3 = new Thread(new Runnable() {
            @Override
            public void run() {
                //调用资源类的操作方法
                for (int i = 0; i < 50; i++) {
                    sale.saleTicket();
                }
            }
        }, "cc");

        t1.start();
        t2.start();
        t3.start();

    }
}


//第一步：创建资源类，在资源类中创建属性和操作方法
class Sale{
    //属性：票数
    private int num =50;
    //操作方法：卖票
    public synchronized void saleTicket(){
        //判断是否有票
        if (num >0){
            System.out.println(Thread.currentThread().getName()+"卖出票"+(num--)+"剩下票数："+num);
        }
    }
}

JUC基础学习笔记_第3张图片

2.3Lock接口简介

Lock 锁实现提供了比使用同步方法和语句可以获得的更广泛的锁操作。它们允许更灵活的结构，可能具有非常不同的属性，并且可能支持多个关联的条件对象。Lock 提供了比 synchronized 更多的功能。

2.4使用可重入锁(ReentrantLock)实现卖票例子

/**
 * @author yzh
 * @date 2023-12-25
 */

import java.util.concurrent.locks.ReentrantLock;

/**
 * 例子：50张票，三个售票员卖票
 * 第一步：创建资源类，在资源类中创建属性和操作方法
 * 第二步：创建多个线程，调用资源类的操作方法
 *  Lock接口实现
 */
public class Dome0003 {
    public static void main(String[] args) {
        //创建Ticket对象
        Ticket ticket = new Ticket();
        //创建三个线程
       new Thread(()->{
           for (int i = 0; i < 50; i++) {
               ticket.saleTicket();
           }
       },"aa").start();
       new Thread(()->{
           for (int i = 0; i < 50; i++) {
               ticket.saleTicket();
           }
       },"bb").start();
        new Thread(() -> {
            for (int i = 0; i < 50; i++) {
                ticket.saleTicket();
            }
        }, "cc").start();
    }

}


class Ticket{
    //票数量
    private int num = 50;
    //创建可重入锁(ReentrantLock)
    private final ReentrantLock lock = new ReentrantLock();
    public void saleTicket(){
        //上锁
        lock.lock();
        try {
            //判断是否有票可卖
            if (num >0){
                System.out.println(Thread.currentThread().getName()+"卖出票"+(num--)+"剩下票数："+num);
            }
        } finally {
            //解锁
            lock.unlock();
        }
    }
}

JUC基础学习笔记_第4张图片

2.4.Lock接口与synchronized的区别

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

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

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

4.通过 Lock 可以知道有没有成功获取锁，而 synchronized 却无法办到。

5.Lock 可以提高多个线程进行读操作的效率。在性能上来说，如果竞争资源不激烈，两者的性能是差不多的，而当竞争资源非常激烈时( 即有大量线程同时竞争 )，此时 Lock 的性能要远远优于synchronized。

3.线程间的通信

3.1synchronized实现创建两个线程对同一资源进行操作 一个加+1，一个-1

/**
 * @author yzh
 * @date 2023-12-25
 */

/**
 * 例子：创建两个线程对同一资源进行操作  一个加+1，一个-1
 * 第一步：创建资源类创建属性和操作方法
 * 第二步：判断、干活、通知
 * 第三步：创建多个线程调用资源类的方法
 */
public class Dome0004 {
    public static void main(String[] args) {
        Share share = new Share();
        new Thread(() -> {
            for (int i = 1; i <= 10; i++) {
                try {
                    share.incr();//+1
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
            }
        }, "aa").start();
        new Thread(() -> {
            for (int i = 1; i <= 10; i++) {
                try {
                    share.decr();//-1
                } catch (InterruptedException e) {

                }
            }
        }, "bb").start();
    }

}

class Share {
    //初始值
    public int num = 0;

    //+1方法
    public synchronized void incr() throws InterruptedException {
        //判断 num 值是否为0，不为0进行等待，为0 +1
        if (num != 0) {
            this.wait();
        }
        num++;
        System.out.println(Thread.currentThread().getName() + "---" + num);
        //通知其他线程
        this.notifyAll();

    }

    //-1方法
    public synchronized void decr() throws InterruptedException {
        //判断 num 值是否为0，不为0 -1，为0 进行等待
        if (num == 0) {
            this.wait();
        }
        num--;
        System.out.println(Thread.currentThread().getName() + "---" + num);
        //通知其他线程
        this.notifyAll();

    }
}

JUC基础学习笔记_第5张图片

注意wait()可能存在虚假唤醒问题

wait在哪里睡，就会在哪里醒。

/**
 * @author yzh
 * @date 2023-12-25
 */

/**
 * 例子：创建两个线程对同一资源进行操作  一个加+1，一个-1
 * 第一步：创建资源类创建属性和操作方法
 * 第二步：判断、干活、通知
 * 第三步：创建多个线程调用资源类的方法
 */
public class Dome0004 {
    public static void main(String[] args) {
        Share share = new Share();
        new Thread(() -> {
            for (int i = 1; i <= 10; i++) {
                try {
                    share.incr();//+1
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
            }
        }, "aa").start();
        new Thread(() -> {
            for (int i = 1; i <= 10; i++) {
                try {
                    share.decr();//-1
                } catch (InterruptedException e) {

                }
            }
        }, "bb").start();
        new Thread(() -> {
            for (int i = 1; i <= 10; i++) {
                try {
                    share.incr();//-1
                } catch (InterruptedException e) {

                }
            }
        }, "cc").start();
        new Thread(() -> {
            for (int i = 1; i <= 10; i++) {
                try {
                    share.decr();//-1
                } catch (InterruptedException e) {

                }
            }
        }, "dd").start();
    }

}

class Share {
    //初始值
    public int num = 0;

    //+1方法
    public synchronized void incr() throws InterruptedException {
        //判断 num 值是否为0，不为0进行等待，为0 +1
        if (num != 0) {
            //wait在哪里睡，就会在哪里醒。
            this.wait();
        }
        num++;
        System.out.println(Thread.currentThread().getName() + "---" + num);
        //通知其他线程
        this.notifyAll();

    }

    //-1方法
    public synchronized void decr() throws InterruptedException {
        //判断 num 值是否为0，不为0 -1，为0 进行等待
        if (num == 0) {
            //wait在哪里睡，就会在哪里醒。
            this.wait();
        }
        num--;
        System.out.println(Thread.currentThread().getName() + "---" + num);
        //通知其他线程
        this.notifyAll();

    }
}

JUC基础学习笔记_第6张图片

JUC基础学习笔记_第7张图片

大于1和大于2的值出现的原因就是因为wait()的虚假唤醒问题

因为当多个线程执行时，

notifyAll()是随机唤醒所有线程

如：第一次aa抢到锁，应该加1，  此时值为1

        第二次cc抢到锁，值为1进入等待状态，并且释放锁，唤醒其他线程

        第三次aa抢到锁，值为1进入等待状态，并且释放锁，唤醒其他线程

        第四次cc抢到锁，值虽然为1，但是此时cc唤醒时，是已经执行if后的位置，所以值会被再次+1变为2.

        。。。。

其他情况同理所得。

此题解决方法：

将if换为while


/**
 * @author yzh
 * @date 2023-12-25
 */

/**
 * 例子：创建两个线程对同一资源进行操作  一个加+1，一个-1
 * 第一步：创建资源类创建属性和操作方法
 * 第二步：判断、干活、通知
 * 第三步：创建多个线程调用资源类的方法
 */
public class Dome0004 {
    public static void main(String[] args) {
        Share share = new Share();
        new Thread(() -> {
            for (int i = 1; i <= 10; i++) {
                try {
                    share.incr();//+1
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
            }
        }, "aa").start();
        new Thread(() -> {
            for (int i = 1; i <= 10; i++) {
                try {
                    share.decr();//-1
                } catch (InterruptedException e) {

                }
            }
        }, "bb").start();
        new Thread(() -> {
            for (int i = 1; i <= 10; i++) {
                try {
                    share.incr();//-1
                } catch (InterruptedException e) {

                }
            }
        }, "cc").start();
        new Thread(() -> {
            for (int i = 1; i <= 10; i++) {
                try {
                    share.decr();//-1
                } catch (InterruptedException e) {

                }
            }
        }, "dd").start();
    }

}

class Share {
    //初始值
    public int num = 0;

    //+1方法
    public synchronized void incr() throws InterruptedException {
        //判断 num 值是否为0，不为0进行等待，为0 +1
        while (num != 0) {
            //wait在哪里睡，就会在哪里醒。
            this.wait();
        }
        num++;
        System.out.println(Thread.currentThread().getName() + "::" + num);
        //通知其他线程
        this.notifyAll();

    }

    //-1方法
    public synchronized void decr() throws InterruptedException {
        //判断 num 值是否为0，不为0 -1，为0 进行等待
        while (num == 0) {
            //wait在哪里睡，就会在哪里醒。
            this.wait();
        }
        num--;
        System.out.println(Thread.currentThread().getName() + "::" + num);
        //通知其他线程
        this.notifyAll();

    }
}

JUC基础学习笔记_第8张图片

JUC基础学习笔记_第9张图片

3.2Lock实现创建两个线程对同一资源进行操作 一个加+1，一个-1


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

/**
 * @author yzh
 * @date 2023-12-25
 */

public class Dome0005 {
    public static void main(String[] args) {
        Share1 share1 = new Share1();
        new Thread(() -> {
            for (int i = 1; i <= 10; i++) {
                try {
                    share1.incr();//+1
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
            }
        }, "aa").start();
        new Thread(() -> {
            for (int i = 1; i <= 10; i++) {
                try {
                    share1.decr();//-1
                } catch (InterruptedException e) {

                }
            }
        }, "bb").start();
        new Thread(() -> {
            for (int i = 1; i <= 10; i++) {
                try {
                    share1.incr();//-1
                } catch (InterruptedException e) {

                }
            }
        }, "cc").start();
        new Thread(() -> {
            for (int i = 1; i <= 10; i++) {
                try {
                    share1.decr();//-1
                } catch (InterruptedException e) {

                }
            }
        }, "dd").start();
    }
    }


class Share1 {
    //初始值
    public int num = 0;
    //创建lock
    private Lock lock = new ReentrantLock();
    private Condition condition = lock.newCondition();


    //+1方法
    public void incr() throws InterruptedException {
        lock.lock();
        try {
            //判断 num 值是否为0，不为0进行等待，为0 +1
            while (num != 0) {
                //wait在哪里睡，就会在哪里醒。
                condition.await();
            }
            num++;
            System.out.println(Thread.currentThread().getName() + "::" + num);
            //通知其他线程
            condition.signalAll();
        } finally {
            lock.unlock();
        }
    }

    //-1方法
    public synchronized void decr() throws InterruptedException {
        lock.lock();
        try {
            //判断 num 值是否为0，不为0 -1，为0 进行等待
            while (num == 0) {
                //wait在哪里睡，就会在哪里醒。
                condition.await();
            }
            num--;
            System.out.println(Thread.currentThread().getName() + "::" + num);
            //通知其他线程
            condition.signalAll();
        } finally {
            lock.unlock();
        }
    }

JUC基础学习笔记_第10张图片

3.3线程间定制化通信

启动三个线程，按照如下要求实现

aa打印5次，bb打印10次，cc打印15次   按照顺序进行10轮

实现思路：利用标志位进行判断实现：

JUC基础学习笔记_第11张图片

/**
 * @author yzh
 * @date 2023-12-25
 */

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

/**
 * 启动三个线程，按照如下要求实现
 * aa打印5次，bb打印10次，cc打印15次  按照顺序进行10轮
 */

public class Dome0006 {
    public static void main(String[] args) {
        ShareResource shareResource = new ShareResource();
        new Thread(()->{
            for (int i = 1; i <=10 ; i++) {
                try {
                    shareResource.print5(i);
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
            }
        },"aa").start();
        new Thread(()->{
            for (int i = 1; i <=10 ; i++) {
                try {
                    shareResource.print10(i);
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
            }
        },"bb").start();
        new Thread(()->{
            for (int i = 1; i <=10 ; i++) {
                try {
                    shareResource.print15(i);
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
            }
        },"cc").start();
    }
}


//创建资源类
class ShareResource{
    //定义标志位 1代表aa线程  2代表bb线程  3代表cc线程
    private int flag = 1;
    //创建lock锁
    private Lock lock =new ReentrantLock();

    //创建三个condition
    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 = 1; i <=5 ; i++) {
                System.out.println(Thread.currentThread().getName()+"::"+i+",第"+loop+"轮");
            }
            //修改标志位为2
            flag=2;
            //通知bb线程
            c2.signal();
        }finally {
            lock.unlock();
        }
    }
    //打印10次,参数第几轮
    public void print10(int loop) throws InterruptedException {
        lock.lock();
        try {
            //判断
            while (flag !=2){
                c2.await();
            }
            for (int i = 1; i <=10 ; i++) {
                System.out.println(Thread.currentThread().getName()+"::"+i+",第"+loop+"轮");
            }
            //修改标志位为2
            flag=3;
            //通知bb线程
            c3.signal();
        }finally {
            lock.unlock();
        }
    }
    //打印15次,参数第几轮
    public void print15(int loop) throws InterruptedException {
        lock.lock();
        try {
            //判断
            while (flag !=3){
                c3.await();
            }
            for (int i = 1; i <=15 ; i++) {
                System.out.println(Thread.currentThread().getName()+"::"+i+",第"+loop+"轮");
            }
            //修改标志位为2
            flag=1;
            //通知bb线程
            c1.signal();
        }finally {
            lock.unlock();
        }
    }
}

JUC基础学习笔记_第12张图片

4.ArrayList集合间的线程安全问题

4.1ArrayList集合线程不安全问题演示

package myjuc;

/**
 * @author yzh
 * @date 2024-01-08
 */

import java.util.ArrayList;
import java.util.UUID;

/**
 * list 集合线程不安全问题
 */
public class ThreadDome001 {
    public static void main(String[] args) {
        //创建ArrayList集合
        ArrayList list = new ArrayList<>();

        for (int i = 0; i < 10; i++) {
            new Thread(()->{
                //向集合中添加内容
                list.add(UUID.randomUUID().toString().substring(0,8));
                //从集合中取出内容
                System.out.println(list);
            },String.valueOf(i)).start();
        }
    }
}

出现问题：

JUC基础学习笔记_第13张图片

原因：

ArrayList中add方法没有被synchronized等修饰，存在线程安全问题。

多个线程并发地向ArrayList集合中添加元素，并在添加后打印出集合的内容。然而，ArrayList不是线程安全的集合类，这可能会导致ConcurrentModificationException异常

JUC基础学习笔记_第14张图片

4.2解决方案 Vector

package myjuc;

import java.util.ArrayList;
import java.util.UUID;
import java.util.Vector;

/**
 * @author yzh
 * @date 2024-01-08
 */
/*
Vector 集合解决线程安全问题
 */
public class ThreadDome002 {
    public static void main(String[] args) {
        //创建Vector集合
        Vector list = new Vector<>();
        for (int i = 0; i < 10; i++) {
            new Thread(()->{
                //向集合中添加内容
                list.add(UUID.randomUUID().toString().substring(0,8));
                //从集合中取出内容
                System.out.println(list);
            },String.valueOf(i)).start();
        }
    }
}

JUC基础学习笔记_第15张图片

解决原因：

Vector中add方法被synchronized等修饰，解决线程安全问题。

4.3解决方案

package myjuc;

import java.util.*;

/**
 * @author yzh
 * @date 2024-01-08
 */

/**
 * Conllections解决线程安全问题
 */
public class ThreadDome003 {
    public static void main(String[] args) {
        //通过工具类Conllections
        List list =  Collections.synchronizedList(new ArrayList());
        for (int i = 0; i < 10; i++) {
            new Thread(()->{
                //向集合中添加内容
                list.add(UUID.randomUUID().toString().substring(0,8));
                //从集合中取出内容
                System.out.println(list);
            },String.valueOf(i)).start();
        }
    }
}

JUC基础学习笔记_第16张图片

4.4解决方案 CopyOnWriteArrayList

package myjuc;

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.UUID;
import java.util.concurrent.CopyOnWriteArrayList;

/**
 * @author yzh
 * @date 2024-01-08
 */

public class ThreadDome004 {
    public static void main(String[] args) {
        //创建CopyOnWriteArrayList集合
        CopyOnWriteArrayList list = new CopyOnWriteArrayList<>();
        for (int i = 0; i < 10; i++) {
            new Thread(()->{
                //向集合中添加内容
                list.add(UUID.randomUUID().toString().substring(0,8));
                //从集合中取出内容
                System.out.println(list);
            },String.valueOf(i)).start();
        }
    }
}

JUC基础学习笔记_第17张图片

CopyOnWriteArrayList的主要思想：写时复制技术

它会先创建该列表的副本，并在副本上进行修改操作，而原始列表保持不变。只有在修改操作完成后，才会将副本替换回原始列表，从而保证了并发安全性。

写时复制的主要思想是牺牲一部分空间来换取并发安全性。当有多个线程同时读取CopyOnWriteArrayList时，它们可以共享同一个原始列表而无需加锁，因为原始列表是不可变的。只有在有写操作时，才会进行复制和修改操作，以确保线程安全。

写时复制的优势在于读操作不需要加锁，从而提高了读取性能。然而，由于每次写操作都需要进行数组的复制，写操作的性能相对较低。因此，如果应用程序有频繁的写操作，而读操作较少，可能会影响整体性能。

CopyOnWriteArrayList的add方法加锁，来保证线程安全问题

JUC基础学习笔记_第18张图片

5.HashSet线程不安全

5.1HashSet线程不安全演示

package myjuc;

import java.util.ArrayList;
import java.util.HashSet;
import java.util.UUID;

/**
 * @author yzh
 * @date 2024-01-08
 */

public class ThreadDome005 {
    public static void main(String[] args) {
        //创建HashSet集合
        HashSet list = new HashSet<>();
        for (int i = 0; i < 10; i++) {
            new Thread(()->{
                //向集合中添加内容
                list.add(UUID.randomUUID().toString().substring(0,8));
                //从集合中取出内容
                System.out.println(list);
            },String.valueOf(i)).start();
        }
    }
}

JUC基础学习笔记_第19张图片

HashSet的add方法没有被synchronized等修饰，存在线程安全问题。

JUC基础学习笔记_第20张图片

5.2解决方案CopyOnWriteArraySet

package myjuc;


import java.util.Set;
import java.util.UUID;
import java.util.concurrent.CopyOnWriteArraySet;

/**
 * @author yzh
 * @date 2024-01-08
 */

public class ThreadDome005 {
    public static void main(String[] args) {
        //创建CopyOnWriteArraySet集合
        Set list = new CopyOnWriteArraySet<>();
        for (int i = 0; i < 10; i++) {
            new Thread(()->{
                //向集合中添加内容
                list.add(UUID.randomUUID().toString().substring(0,8));
                //从集合中取出内容
                System.out.println(list);
            },String.valueOf(i)).start();
        }
    }
}

JUC基础学习笔记_第21张图片

6.HashMap线程不安全

6.1HashMap线程不安全演示

package myjuc;


import java.util.HashMap;
import java.util.UUID;

/**
 * @author yzh
 * @date 2024-01-08
 */

public class ThreadDome005 {
    public static void main(String[] args) {
        //创建HashMap集合
        HashMap map = new HashMap<>();
        for (int i = 0; i < 10; i++) {
            String key = String.valueOf(i);
            new Thread(()->{
                //向集合中添加内容
                map.put(key,UUID.randomUUID().toString().substring(0,8));
                //从集合中取出内容
                System.out.println(map);
            },String.valueOf(i)).start();
        }
    }
}

JUC基础学习笔记_第22张图片6.2解决法案ConcurrentHashMap

package myjuc;


import java.util.UUID;
import java.util.concurrent.ConcurrentHashMap;

/**
 * @author yzh
 * @date 2024-01-08
 */

public class ThreadDome005 {
    public static void main(String[] args) {
        //创建HashMap集合
        ConcurrentHashMap map = new ConcurrentHashMap<>();
        for (int i = 0; i < 10; i++) {
            String key = String.valueOf(i);
            new Thread(()->{
                //向集合中添加内容
                map.put(key,UUID.randomUUID().toString().substring(0,8));
                //从集合中取出内容
                System.out.println(map);
            },String.valueOf(i)).start();
        }
    }
}

JUC基础学习笔记_第23张图片

7.多线程锁

7.1演示synchronized锁的八种情况

package myjuc;

import java.util.concurrent.TimeUnit;

/**
 * @author yzh
 * @date 2024-01-08
 */

/**
 * 1 标准访问，先打印短信还是邮件
 * ------sendSMS
 * ------sendEmail
 * 2 停4秒在短信方法内，先打印短信还是邮件
 * ------sendSMS
 * ------sendEmail
 * 3 新增普通的hello方法，是先打短信还是hello
 * ------getHello
 * ------sendSMS
 * 4 现在有两部手机，先打印短信还是邮件
 * ------sendEmail
 * ------sendSMS
 * 5 两个静态同步方法，1部手机，先打印短信还是邮件
 * ------sendSMS
 * ------sendEmail
 * 6 两个静态同步方法，2部手机，先打印短信还是邮件
 * ------sendSMS
 * ------sendEmail
 * 7 1个静态同步方法,1个普通同步方法，1部手机，先打印短信还是邮件
 * ------sendEmail
 * ------sendSMS
 * 8 1个静态同步方法,1个普通同步方法，2部手机，先打印短信还是邮件
 * ------sendEmail
 * ------sendSMS
 */
public class Dome01 {
    public static void main(String[] args) throws Exception {
        Phone phone = new Phone();
//        Phone phone2 = new Phone();
        new Thread(() -> {
            try {
                phone.sendSMS();
            } catch (Exception e) {
                e.printStackTrace();
            }
        }, "A").start();
        Thread.sleep(100);
        new Thread(() -> {
            try {
//                 phone.sendEmail();
                 phone.getHello();
//                phone2.sendEmail();
            } catch (Exception e) {
                e.printStackTrace();
            }
        }, "B").start();
    }

}

class Phone{
    public  synchronized void sendSMS() throws InterruptedException {
        //停留4s
        TimeUnit.SECONDS.sleep(10);
        System.out.println("------sendSMS");
    }

    public  synchronized void sendEmail(){
        System.out.println("------sendEmail");
    }

    public  void getHello() {
        System.out.println("------getHello");
    }

}

总结：synchronized实现同步的基础:Java中的每一个对象都可以作为锁具体表现为以下3种形式。

对于普通同步方法，锁是当前实例对象

对于静态同步方法，锁是当前类的class对象

对于同步方法块，锁是Synchonized括号里配置的对象

7.2公平锁和非公平锁

非公平锁时：

package myjuc;

import java.util.concurrent.locks.ReentrantLock;

/**
 * @author yzh
 * @date 2024-01-08
 */

public class Dome02 {
    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();
    }
}

 class LTicket {
        //票数
        private int num = 30;
        //创建可重入锁
        private final ReentrantLock lock = new ReentrantLock();

        //售票方法
        public void sale() {
            //上锁
            lock.lock();
            try {
                //判断是否有票
                if (num > 0) {
                    System.out.println(Thread.currentThread().getName() + ": 卖出" + (num--) + "剩余：" + num);
                }
            } finally {
                //解锁
                lock.unlock();
            }
        }
    }

JUC基础学习笔记_第24张图片

此时B和C未抢到一次锁，被饿死

公平锁：

package myjuc;

import java.util.concurrent.locks.ReentrantLock;

/**
 * @author yzh
 * @date 2024-01-08
 */

public class Dome02 {
    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();
    }
}

 class LTicket {
        //票数
        private int num = 30;
        //创建可重入锁
        private final ReentrantLock lock = new ReentrantLock(true);

        //售票方法
        public void sale() {
            //上锁
            lock.lock();
            try {
                //判断是否有票
                if (num > 0) {
                    System.out.println(Thread.currentThread().getName() + ": 卖出" + (num--) + "剩余：" + num);
                }
            } finally {
                //解锁
                lock.unlock();
            }
        }
    }

JUC基础学习笔记_第25张图片

JUC基础学习笔记_第26张图片

ReentrantLock无参构造时默认为非公平锁

  1. 公平锁（Fair Lock）：公平锁是指多个线程按照申请锁的顺序来获取锁，即先到先得的原则。当一个线程尝试获取锁时，如果发现锁已经被其他线程占用，则该线程会被放入等待队列中，等待其他线程释放锁后再次尝试获取锁。公平锁保证了所有线程获取锁的顺序是公平的，避免了饥饿现象，但由于需要维护等待队列，因此可能会降低系统的整体性能。

  2. 非公平锁（Nonfair Lock）：非公平锁是指多个线程获取锁的顺序是不确定的，不按照申请锁的顺序来进行。当一个线程尝试获取锁时，如果锁还没有被其他线程占用，则该线程可以直接获取到锁；如果锁已经被其他线程占用，则该线程会一直尝试获取锁，直到获取成功。非公平锁允许新到来的线程优先获取锁，这样可以提高系统的吞吐量，但可能会导致某些线程长时间等待，产生饥饿现象。

综上所述，公平锁和非公平锁的主要区别在于线程获取锁的顺序。公平锁按照申请锁的顺序来获取锁，保证了线程获取锁的公平性，但可能降低系统性能；非公平锁允许新到来的线程优先获取锁，提高了系统的吞吐量，但可能导致某些线程长时间等待。

7.3可重入锁

可重入锁（Reentrant Lock）是一种支持同一个线程多次获取锁的锁机制。也就是说，当一个线程获得了某个锁之后，可以再次获得该锁而不会被阻塞。可重入锁主要用于解决线程在递归调用或多层级调用中对同一个锁的重复获取的情况。

可重入锁通过一个计数器来记录锁的持有次数，每次成功获取锁时计数器加1，每次释放锁时计数器减1。只有当计数器归零时，其他线程才能获取到该锁。

可重入锁的优点：

  1. 避免死锁：在递归调用或多层级调用中，如果使用普通的互斥锁，线程在第二次获取锁时会被自己阻塞，导致死锁。而可重入锁可以让同一个线程多次获取锁，避免了死锁的发生。
  2. 灵活性：可重入锁提供了更灵活的锁获取和释放方式，可以根据具体的业务需求灵活控制锁的获取和释放操作。

synchronized和lock都是可重入锁。

  • sychronized是隐式锁，不用手工上锁与解锁，而lock为显示锁，需要手工上锁与解锁
package myjuc;

/**
 * @author yzh
 * @date 2024-01-08
 */

public class Dome03 {
    public synchronized void add(){
        add();
    }
    public static void main(String[] args) {
        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();
        new Dome03().add();
    }
}

JUC基础学习笔记_第27张图片

此时出现栈溢出异常，就形象的说明了synchronized为可重入锁，因为如果synchronized为不可重入锁，那么add方法就只能被调用一次然后发生死锁，而此时的add方法被无限循环调用导致栈溢出。

package myjuc;

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

/**
 * @author yzh
 * @date 2024-01-08
 */

public class Dome03 {
    public synchronized void add() {
        add();
    }

    public static void main(String[] args) {
        //lock演示可重入锁
        Lock lock = new ReentrantLock();
        //创建线程
        new Thread(() -> {
        try {
            //上锁
            lock.lock();
            System.out.println(Thread.currentThread().getName() + "外层");
            try {
                //上锁
                lock.lock();
                System.out.println(Thread.currentThread().getName() + "中层");
                try {
                    //上锁
                    lock.lock();
                    System.out.println(Thread.currentThread().getName() + "内层");

                } finally {
                    lock.unlock();
                }
            } finally {
                lock.unlock();
            }

        } finally {
            lock.unlock();
        }
        },"A").start();

        new Thread(()->{
            try {
                lock.lock();
                System.out.println(Thread.currentThread().getName()+"bb");
            }finally {
                lock.unlock();
            }
        },"B").start();
    }
}

JUC基础学习笔记_第28张图片

如果上面线程有一个锁未释放第一个线程不会被影响执行，第二个线程会一直获取不到锁JUC基础学习笔记_第29张图片

JUC基础学习笔记_第30张图片

7.4死锁

死锁（Deadlock）是指两个或多个线程在互相等待对方释放资源而无法继续执行的状态，从而导致程序无法继续运行下去。当发生死锁时，线程将永久地阻塞在这个状态上，无法进行任何进一步的操作。

一个典型的死锁场景包括以下几个条件：

  1. 互斥条件（Mutual Exclusion）：至少有一个资源同时只能被一个线程持有。
  2. 请求与保持条件（Hold and Wait）：一个线程在持有一个资源的同时，又请求其他线程持有的资源。
  3. 不可剥夺条件（No Preemption）：已经分配给一个线程的资源不能被强制性地剥夺。
  4. 循环等待条件（Circular Wait）：存在一个进程资源的循环链，每个进程都在等待下一个进程所持有的资源。

JUC基础学习笔记_第31张图片

package myjuc;

/**
 * @author yzh
 * @date 2024-01-08
 */

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();
    }
}

互相等待，发生死锁JUC基础学习笔记_第32张图片

验证死锁：

1.jps -l

2.jstack port

如

JUC基础学习笔记_第33张图片

此时展示信息：

JUC基础学习笔记_第34张图片

JUC基础学习笔记_第35张图片

8.Callable接口

  • Callable接口方法是call()，Runnable的方法是run()；
  • Callable接口call方法有返回值，支持泛型，Runnable接口run方法无返回值。
  • Callable接口call()方法允许抛出异常；而Runnable接口run()方法不能继续上抛异常。

Callable创建线程：

package myjuc;

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;

/**
 * @author yzh
 * @date 2024-01-09
 */
//比较Runnable和Callable的区别
public class Dome05 {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        //Runnable创建线程
        MyTest1 t1 = new MyTest1();
        new Thread(t1,"A").start();

        //Callable创建线程
        //FutureTask
        FutureTask t2 = new FutureTask(new MyTest2());
        //lamd表达式
        FutureTask t3 = new FutureTask<>(() -> {
            System.out.println(Thread.currentThread().getName()+"t3");
            return 1024;
        });
        new Thread(t2,"B").start();
        new Thread(t3,"c").start();
        //调用FutureTask的isDone方法判断t3线程是否完成
        while (!t3.isDone()){
            System.out.println("wait.......");
        }
        //调用FutureTask的get方法获取线程的执行结果
        System.out.println(t2.get());
        System.out.println(t3.get());

        System.out.println(Thread.currentThread().getName()+"over");

        //FutureTask原理      未来任务
        /**
         * 1.老师上课，口渴了，去买票不合适，讲课线程继续单开启线程找班上班长帮我买水，把水买回来，需要时候直接get
         *
         * 2.现在有4个同学，1同学 1+2...52同学 10+11+12....50 ，3同学 60+61+62 ，4同学 100+200第2个同学计算量比较大
         *      FutureTask单开启线程给2同学计算，先汇总 1 3 4，最后等2同学计算位完成，统一汇总
         *
         * 3.考试，做会做的题目，最后看不会做的题目
         *
         *
         * 最终汇总的值只需要汇总一次即可
         */
    }
}

class  MyTest1 implements Runnable{
    @Override
    public void run() {
        System.out.println("Runnable启动");

    }
}

class MyTest2 implements Callable{
    @Override
    public Object call() throws Exception {
        System.out.println(Thread.currentThread().getName()+"t2");
        return 100;
    }
}

JUC基础学习笔记_第36张图片

JUC基础学习笔记_第37张图片

9.JUC中的辅助类

9.1减少计数CountDownLatch

CountDownLatch 是 Java 中的一个同步辅助类，可以用于控制多个线程之间的执行顺序。

CountDownLatch 类提供了一个计数器，通过调用 countDown() 方法来减少计数器的值，并通过调用 await() 方法来阻塞线程，直到计数器的值变为零。当计数器的值变为零时，所有在调用 await() 方法阻塞的线程将被释放，可以继续执行。

CountDownLatch 主要用于一组线程等待其他线程完成操作后再继续执行。它的典型应用场景包括：

  1. 主线程等待所有工作线程完成任务后再继续执行。
  2. 多个工作线程等待某个共享资源就绪后再同时执行。

JUC基础学习笔记_第38张图片

例子：

没有用CountDownLatch时可能出现同学还未全部离开老师就锁门

package myjuc;

/**
 * @author yzh
 * @date 2024-01-09
 */
//演示 CountDownLatch
public class Dome06 {
    //6个同学离开教室老师才能锁门，
    public static void main(String[] args) {
        //6个同学陆续离开教室
        for (int i = 1; i <= 6; i++) {
            new Thread(()->{
                System.out.println(Thread.currentThread().getName()+"同学离开教室");
            },String.valueOf(i)).start();
        }
        System.out.println(Thread.currentThread().getName()+"老师锁门");
    }
}

JUC基础学习笔记_第39张图片

使用CountDownLatch：

package myjuc;

import java.util.concurrent.CountDownLatch;

/**
 * @author yzh
 * @date 2024-01-09
 */
//演示 CountDownLatch
public class Dome06 {
    //6个同学离开教室老师才能锁门，
    public static void main(String[] args) throws InterruptedException {
        //创建CountDownLatch对象，设置初始值
        CountDownLatch countDownLatch = new CountDownLatch(6);
        //6个同学陆续离开教室
        for (int i = 1; i <=6; i++) {
            new Thread(()->{
                System.out.println(Thread.currentThread().getName()+"同学离开教室");
                //让计数器每次-1
                countDownLatch.countDown();
            },String.valueOf(i)).start();
        }
        //等待
        countDownLatch.await();
        System.out.println(Thread.currentThread().getName()+"老师锁门");
    }
}

JUC基础学习笔记_第40张图片

9.2循环栅栏CyclicBarrier

CyclicBarrier 是 Java 中的一个同步辅助类，可以用于控制多个线程之间的执行顺序。

CyclicBarrier 类提供了一个等待点，当多个线程到达这个等待点时，CyclicBarrier 将会把它们阻塞在这里，直到所有线程都到达这个等待点。当所有线程都到达这个等待点时，CyclicBarrier 将会解除阻塞，所有线程继续执行。

CyclicBarrier 主要用于多个线程之间需要相互等待的场景，例如多个线程需要等待某个共享资源就绪后再同时执行。

JUC基础学习笔记_第41张图片

JUC基础学习笔记_第42张图片

例子：

集齐7龙珠召唤神龙
package myjuc;

import java.util.concurrent.BrokenBarrierException;
import java.util.concurrent.CyclicBarrier;

/**
 * @author yzh
 * @date 2024-01-09
 */
//集齐7龙珠召唤神龙
public class Dome07 {
    //创建固定值
    private static final int num =7;
    public static void main(String[] args) {
    //创建CyclicBarrier对象
        CyclicBarrier barrier = new CyclicBarrier(num, () -> {
            System.out.println("**集齐7龙珠召唤神龙**");
        });
        //集齐七颗龙珠的过程
        for (int i = 1; i <=7 ; i++) {
            new Thread(()->{
                try {
                    System.out.println(Thread.currentThread().getName()+"被收集");
                    //等待
                    barrier.await();
                } catch (Exception e) {
                    throw new RuntimeException(e);
                }
            },String.valueOf(i)).start();
        }
    }
}

JUC基础学习笔记_第43张图片

9.3信号灯Semaphore

Semaphore 是 Java 中的一个同步辅助类，用于控制同时访问某个资源的线程数量。

Semaphore 维护了一组许可证（permits），线程可以通过调用 acquire() 方法获取许可证，或者通过调用 release() 方法释放许可证。每个 acquire() 方法调用都会阻塞线程，直到获得一个许可证为止。而每个 release() 方法调用都会释放一个许可证。

Semaphore 主要用于控制同时执行某个特定操作的线程数量，例如限制同时访问某个共享资源的线程数量。它可以解决并发访问问题，确保多个线程之间的安全性。

JUC基础学习笔记_第44张图片

JUC基础学习笔记_第45张图片

JUC基础学习笔记_第46张图片

例子：

现在有6辆汽车，停在3个停车位

package myjuc;

import java.util.Random;
import java.util.concurrent.Semaphore;
import java.util.concurrent.TimeUnit;

/**
 * @author yzh
 * @date 2024-01-09
 */
//现在有6辆汽车，停在3个停车位
public class Dome8 {
    public static void main(String[] args) {
        //创建Semaphore，设置许可量
        Semaphore semaphore = new Semaphore(3);
        //模拟6辆汽车
        for (int i = 1; i <=6 ; i++) {
            new Thread(()->{
                //抢占
                try {
                    semaphore.acquire();
                    System.out.println(Thread.currentThread().getName()+"停在停车位");
                    //设置随机停车时间
                    TimeUnit.SECONDS.sleep(new Random().nextInt(5));
                    System.out.println(Thread.currentThread().getName()+"**离开停车位");

                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }finally {
                    //释放
                    semaphore.release();
                }
            },String.valueOf(i)).start();
        }
    }
}

JUC基础学习笔记_第47张图片

10.ReentrantReadWriteLock读写锁

10.1悲观锁和乐观锁

悲观锁，每次访问资源都会加锁，执行完同步代码释放锁，synchronized和ReentrantLock属于悲观锁。

乐观锁，不会锁定资源，所有的线程都能访问并修改同一个资源，如果没有冲突就修改成功并退出，否则就会继续循环尝试。乐观锁最常见的实现就是CAS。

适用场景：

  • 悲观锁适合写操作多的场景。
  • 乐观锁适合读操作多的场景，不加锁可以提升读操作的性能。

JUC基础学习笔记_第48张图片

JUC基础学习笔记_第49张图片

10.2表锁和行锁

表锁（Table Lock）和行锁（Row Lock）是数据库中常见的锁机制，用于控制对数据库对象（如表、行）的并发访问。

  1. 表锁（Table Lock）：

    • 表锁是在操作整个表时加锁，对整个表进行加锁操作，可以阻塞其他事务对该表的读写操作。
    • 表锁具有较低的粒度，锁定了整个表，因此会对并发性能产生影响。
    • 当一个事务获取表锁后，其他事务无法同时对同一表进行写操作或者部分读操作，这可能导致并发性能下降。

  2. 行锁（Row Lock）：

    • 行锁是在操作表中的行数据时加锁，只锁定需要操作的行，而不是整个表。
    • 行锁具有较高的粒度，只影响到涉及到的行数据，对其他行的读写操作不受影响。
    • 当一个事务获取某一行的行锁后，其他事务可以同时对其他行进行读写操作，不会被阻塞。

行锁可能发生死锁

10.3读锁和写锁

  1. 读锁（Shared Lock）：

    • 也称为共享锁，多个事务可以同时获取读锁，允许并发地进行读操作。
    • 若一个事务持有了读锁，则其他事务也可以获取读锁，而不会被阻塞。
    • 读锁适用于读多写少的场景，可以提高并发性能。
    • 读锁之间不会产生冲突，即多个事务可以同时持有读锁。

  2. 写锁（Exclusive Lock）：

    • 也称为排它锁（独占式锁），只允许一个事务持有写锁，其他事务无法同时获取读锁或写锁。
    • 若一个事务已经持有写锁，则其他事务无法同时获取写锁或读锁，会被阻塞等待。
    • 写锁适用于写多读少的场景，确保数据的一致性和完整性。
    • 写锁之间和读锁之间都会产生冲突，即写锁与任何其他锁都不能同时存在。

共享式与独占式的最主要区别在于：同一时刻独占式只能有一个线程获取同步状态，而共享式在同一时刻可以有多个线程获取同步状态。例如读操作可以有多个线程同时进行，而写操作同一时刻只能有一个线程进行写操作，其他操作都会被阻塞。

读锁发生死锁场景：

JUC基础学习笔记_第50张图片

写锁发生死锁场景

JUC基础学习笔记_第51张图片

未上锁时：

package myjuc;

import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.TimeUnit;

/**
 * @author yzh
 * @date 2024-01-09
 */
//资源类
class MyCache {
    //创建map集合
    private volatile Map map = new HashMap<>();

    //向map集合中放数据
    public void add(String key, Object value) {
        System.out.println(Thread.currentThread().getName() + "正在写操作" + key);
        //暂停一下
        try {
            TimeUnit.MICROSECONDS.sleep(300);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
        //放数据
        map.put(key, value);
        System.out.println(Thread.currentThread().getName() + "写完了" + key);
    }

    //向map集合中读数据
    public Object get(String key) {
        Object result = null;
        System.out.println(Thread.currentThread().getName() + "正在读取操作" + key);
        //暂停一下
        try {
            TimeUnit.MICROSECONDS.sleep(300);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
        //放数据
        result = map.get(key);
        System.out.println(Thread.currentThread().getName() + "读取完了" + key);
        return result;
    }

}

public class Dome08 {

    public static void main(String[] args) {
        MyCache myCache = new MyCache();

        //创建5个线程放数据
        for (int i = 1; i <= 5; i++) {
            final int num = i;
            new Thread(() -> {
                myCache.add(String.valueOf(num), num);
            }, String.valueOf(i)).start();
        }
        //创建5个线程读数据
        for (int i = 1; i <= 5; i++) {
            final int num = i;
            new Thread(() -> {
                myCache.get(String.valueOf(num));
            }, String.valueOf(i)).start();
        }

    }
}

JUC基础学习笔记_第52张图片

发现写操作还未完成时，读操作就已经正在进行。

使用ReentrantReadWriteLock解决这一问题

package myjuc;

import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.ReadWriteLock;
import java.util.concurrent.locks.ReentrantReadWriteLock;

/**
 * @author yzh
 * @date 2024-01-09
 */
//资源类
class MyCache {
    //创建map集合
    private volatile Map map = new HashMap<>();

    //创建ReentrantReadWriteLock对象
    private ReadWriteLock readWriteLock =new ReentrantReadWriteLock();

    //向map集合中放数据
    public void add(String key, Object value) {
        //添加写锁
        readWriteLock.writeLock().lock();
        try {
            System.out.println(Thread.currentThread().getName() + "正在写操作" + key);
            //暂停一下
            TimeUnit.MICROSECONDS.sleep(300);
            //放数据
            map.put(key, value);
            System.out.println(Thread.currentThread().getName() + "写完了" + key);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }finally {
            //释放写锁
            readWriteLock.writeLock().unlock();
        }
    }

    //向map集合中读数据
    public Object get(String key) {
        //添加读锁
        readWriteLock.readLock().lock();
        Object result = null;
        try {
            System.out.println(Thread.currentThread().getName() + "正在读取操作" + key);
            //暂停一下
            TimeUnit.MICROSECONDS.sleep(300);
            //放数据
            result = map.get(key);
            System.out.println(Thread.currentThread().getName() + "读取完了" + key);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }finally {
            //释放读锁
            readWriteLock.readLock().unlock();
        }

        return result;
    }

}

public class Dome08 {

    public static void main(String[] args) {
        MyCache myCache = new MyCache();

        //创建5个线程放数据
        for (int i = 1; i <= 5; i++) {
            final int num = i;
            new Thread(() -> {
                myCache.add(String.valueOf(num), num);
            }, String.valueOf(i)).start();
        }
        //创建5个线程读数据
        for (int i = 1; i <= 5; i++) {
            final int num = i;
            new Thread(() -> {
                myCache.get(String.valueOf(num));
            }, String.valueOf(i)).start();
        }

    }
}

JUC基础学习笔记_第53张图片

运行效果也说明了读锁为共享锁，写锁为独占锁。

注意：读写锁:一个资源可以被多个读线程访问，或者可以被一个写线程访问，但是不能同时存在读写线程，读写互斥，读读共享的

JUC基础学习笔记_第54张图片

10.4锁降级

锁降级是指在持有一个较高级别的锁的情况下，获取一个较低级别的锁，并释放掉较高级别的锁，以降低锁的粒度和提高并发性能。

具体来说，锁降级包括以下步骤：

  1. 首先，获取一个较高级别的锁，例如写锁。
  2. 然后，在持有较高级别锁的情况下，获取一个较低级别的锁，例如读锁。
  3. 接着，释放掉较高级别的锁，只保留较低级别的锁。
  4. 最后，完成对锁的操作，释放掉较低级别的锁。

通过锁降级，可以减少锁的争用范围，提高并发性能。因为在降级后，其他线程可以同时获取较低级别的锁，并行地执行读操作，而不需要等待较高级别的锁。

需要注意的是，锁降级需要按照特定的顺序获取和释放锁，以避免发生死锁或数据不一致的情况。具体的顺序规则取决于具体的应用场景和锁的类型。

锁降级在某些并发场景中非常有用，例如在数据库事务中的读写操作，可以先获取写锁进行写操作，然后降级为读锁进行读操作，以保证数据的一致性和并发性能。

需要注意的是，并非所有的锁都支持降级操作，具体取决于使用的锁的类型和实现。在使用锁降级时，需要仔细阅读相关文档并确保所使用的锁支持降级操作。

JUC基础学习笔记_第55张图片

注意：读锁不能升级为写锁

演示代码：

package myjuc;

import java.util.concurrent.locks.ReentrantReadWriteLock;

/**
 * @author yzh
 * @date 2024-01-09
 */
//演示读锁降级为写锁
public class Dome09 {
    public static void main(String[] args) {
        //可重入读写锁对象
        ReentrantReadWriteLock readWriteLock = new ReentrantReadWriteLock();
        //读锁
        ReentrantReadWriteLock.ReadLock readLock = readWriteLock.readLock();
        //写锁
        ReentrantReadWriteLock.WriteLock writeLock = readWriteLock.writeLock();

        //锁降级
        //1.获取写锁
        writeLock.lock();
        System.out.println("锁降级");
        //2.获取读锁
        readLock.lock();
        System.out.println("**read");

        //3.释放写锁
        writeLock.unlock();
        //4.释放读锁
        readLock.unlock();
    }
}

JUC基础学习笔记_第56张图片

反向操作代码：

package myjuc;

import java.util.concurrent.locks.ReentrantReadWriteLock;

/**
 * @author yzh
 * @date 2024-01-09
 */
//演示读锁降级为写锁
public class Dome09 {
    public static void main(String[] args) {
        //可重入读写锁对象
        ReentrantReadWriteLock readWriteLock = new ReentrantReadWriteLock();
        //读锁
        ReentrantReadWriteLock.ReadLock readLock = readWriteLock.readLock();
        //写锁
        ReentrantReadWriteLock.WriteLock writeLock = readWriteLock.writeLock();

        //锁降级
        //2.获取读锁
        readLock.lock();
        System.out.println("**read");
        //1.获取写锁
        writeLock.lock();
        System.out.println("锁降级");


        //3.释放写锁
        writeLock.unlock();
        //4.释放读锁
        readLock.unlock();
    }
}

JUC基础学习笔记_第57张图片

此时运行结果说明：读锁不能升级为写锁

11.BlockingQueue阻塞队列

11.1阻塞队列概述

阻塞队列顾名思义，首先它是一个队列，通过一个共享队列，可以使数据从一端输入，另一端输出。是一种支持在多线程环境下使用的数据结构，它的特点是当队列为空或已满时，插入和删除操作会被阻塞。

JUC基础学习笔记_第58张图片

当队列是空的，从队列中获取元素的操作将会被阻塞

当队列是满的，从队列中添加元素的操作将会被阻塞

试图从空的队列中获取元素的线程将会被阻塞，直到其他线程往空的队列插入新的元素.

试图向已满的队列中添加新元素的线程将会被阻塞，直到其他线程从队列中移除一个或多元素或者完全清空，使队列变得空闲起来并后续新增

11.2阻塞队列的基本架构

BlockingQueue接口定义了阻塞队列的基本操作，包括put()、take()、offer()、poll()等方法。常用的实现类有：

  1. ArrayBlockingQueue：基于数组实现的阻塞队列，大小固定，读写锁分离，支持公平和非公平两种模式。

  2. LinkedBlockingQueue：基于链表实现的阻塞队列，大小可以选择是否限制（如果没有限制，则容量为Integer.MAX_VALUE），读写锁分离，支持公平和非公平两种模式。

  3. SynchronousQueue：一个不存储元素的阻塞队列，每个插入操作必须等待另一个线程的相应删除操作，反之亦然。

  4. PriorityBlockingQueue：支持优先级排序的阻塞队列，内部使用平衡二叉树实现。

11.3核心方法

JUC基础学习笔记_第59张图片

JUC基础学习笔记_第60张图片

演示：

add和remove

队列长度为3时，若向其中放入4个元素时的异常结果

package myjuc;

import java.util.concurrent.ArrayBlockingQueue;

/**
 * @author yzh
 * @date 2024-01-10
 */

public class Dome10 {
    public static void main(String[] args) {
        //创建阻塞队列
        ArrayBlockingQueue blockingQueue = new ArrayBlockingQueue(3);

        //第一组
        System.out.println(blockingQueue.add("a"));
        System.out.println(blockingQueue.add("b"));
        System.out.println(blockingQueue.add("c"));
        System.out.println(blockingQueue.element());
        System.out.println(blockingQueue.add("f"));
    }
}

JUC基础学习笔记_第61张图片

队列长度为3时，若向其中取出4个元素时的异常结果

package myjuc;

import java.util.concurrent.ArrayBlockingQueue;

/**
 * @author yzh
 * @date 2024-01-10
 */

public class Dome10 {
    public static void main(String[] args) {
        //创建阻塞队列
        ArrayBlockingQueue blockingQueue = new ArrayBlockingQueue(3);

        //第一组
        System.out.println(blockingQueue.add("a"));
        System.out.println(blockingQueue.add("b"));
        System.out.println(blockingQueue.add("c"));
        System.out.println(blockingQueue.element());
        for (int i = 1; i <=4 ; i++) {
            System.out.println(blockingQueue.remove());
        }
    }
}

JUC基础学习笔记_第62张图片

poll和offer方法

package myjuc;

import java.util.concurrent.ArrayBlockingQueue;

/**
 * @author yzh
 * @date 2024-01-10
 */

public class Dome10 {
    public static void main(String[] args) {
        //创建阻塞队列
        ArrayBlockingQueue blockingQueue = new ArrayBlockingQueue(3);

        //第二组
        System.out.println(blockingQueue.offer("a"));
        System.out.println(blockingQueue.offer("b"));
        System.out.println(blockingQueue.offer("c"));
        System.out.println(blockingQueue.offer("d"));

        for (int i = 1; i <=4 ; i++) {
            System.out.println(blockingQueue.poll());
        }
    }
}

JUC基础学习笔记_第63张图片

put和take

put方法放入超过队列长度的元素时会发生阻塞

package myjuc;

import java.util.concurrent.ArrayBlockingQueue;

/**
 * @author yzh
 * @date 2024-01-10
 */

public class Dome10 {
    public static void main(String[] args) throws InterruptedException {
        //创建阻塞队列
        ArrayBlockingQueue blockingQueue = new ArrayBlockingQueue(3);

        //第三组
        blockingQueue.put("a");
        blockingQueue.put("b");
        blockingQueue.put("c");
        blockingQueue.put("d");


    }
}

JUC基础学习笔记_第64张图片

put方法取出超过队列长度的元素时会发生阻塞

package myjuc;

import java.util.concurrent.ArrayBlockingQueue;

/**
 * @author yzh
 * @date 2024-01-10
 */

public class Dome10 {
    public static void main(String[] args) throws InterruptedException {
        //创建阻塞队列
        ArrayBlockingQueue blockingQueue = new ArrayBlockingQueue(3);

        //第三组
        blockingQueue.put("a");
        blockingQueue.put("b");
        blockingQueue.put("c");

        for (int i = 1; i <=4 ; i++) {
            System.out.println(blockingQueue.take());
        }



    }
}

JUC基础学习笔记_第65张图片

offer(E e, long timeout, TimeUnit unit)和poll(long timeout, TimeUnit unit) throws InterruptedException 

package myjuc;

import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.TimeUnit;

/**
 * @author yzh
 * @date 2024-01-10
 */

public class Dome10 {
    public static void main(String[] args) throws InterruptedException {
        //创建阻塞队列
        ArrayBlockingQueue blockingQueue = new ArrayBlockingQueue(3);

        //第四组
        System.out.println(blockingQueue.offer("a"));
        System.out.println(blockingQueue.offer("b"));
        System.out.println(blockingQueue.offer("c"));
        //offer("d",3L, TimeUnit.SECONDS)   3L为超时时间    TimeUnit.SECONDS为时间单位   此时阻塞时间超过3s就会停止
        System.out.println(blockingQueue.offer("d",3L, TimeUnit.SECONDS));


    }
}

JUC基础学习笔记_第66张图片

JUC基础学习笔记_第67张图片

package myjuc;

import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.TimeUnit;

/**
 * @author yzh
 * @date 2024-01-10
 */

public class Dome10 {
    public static void main(String[] args) throws InterruptedException {
        //创建阻塞队列
        ArrayBlockingQueue blockingQueue = new ArrayBlockingQueue(3);

        //第四组
        System.out.println(blockingQueue.offer("a"));
        System.out.println(blockingQueue.offer("b"));
        System.out.println(blockingQueue.offer("c"));


        for (int i = 1; i <=3 ; i++) {
            System.out.println(blockingQueue.poll());
        }
        //poll(3L, TimeUnit.SECONDS)   3L为超时时间    TimeUnit.SECONDS为时间单位   此时阻塞时间超过3s就会停止
        System.out.println(blockingQueue.poll(3L, TimeUnit.SECONDS));


    }
}

JUC基础学习笔记_第68张图片

JUC基础学习笔记_第69张图片

12.ThreadPool线程池

12.1线程池概述

线程池( 英语 : thread pool ) :一种线程使用模式。线程过多会带来调度开销进而影响缓存局部性和整体性能。而线程池维护着多个线程，等待着监督管理者分配可并发执行的任务。这避免了在处理短时间任务时创建与销毁线程的代价。线程池不仅能够保证内核的充分利用，还能防止过分调度。

线程池的优势: 线程池做的工作只要是控制运行的线程数量，处理过程中将任务放入队列，然后在线程创建后启动这些任务，如果线程数量超过了最大数量超出数量的线程排队等候，等其他线程执行完毕，再从队列中取出任务来执行。

线程池的特点：

  • 降低资源消耗。通过重复利用已创建的线程降低线程创建和销毁造成的消耗。
  • 提高响应速度。当任务到达时，可以不需要等到线程创建就能立即执行。
  • 提高线程的可管理性。统一管理线程，避免系统创建大量同类线程而导致消耗完内存。

12.2线程池的使用方法

一池N线程

特点：

线程池中的线程处于一定的量，可以很好的控制线程的并发量

线程可以重复被使用，在显示关闭之前，都将一直存在

超出一定量的线程被提交时候需在队列中等待.

package myjuc;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

/**
 * @author yzh
 * @date 2024-01-10
 */

//演示线程池三种常见分类
public class Dome11 {
    public static void main(String[] args) {
        //一池N线程
        //5个窗口
        ExecutorService pool = Executors.newFixedThreadPool(5);
        //100个顾客
        try {
            for (int i = 1; i <=100 ; i++) {
                final int num =i;
                //执行
                pool.execute(()->{
                    System.out.println(Thread.currentThread().getName()+"正在办理业务"+num);
                });
            }

        }catch (Exception e){
            e.printStackTrace();
        }finally {
            //关闭
            pool.shutdown();
        }


    }
}

JUC基础学习笔记_第70张图片

一个任务一个任务执行，一池一线程

package myjuc;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

/**
 * @author yzh
 * @date 2024-01-10
 */
//演示线程池三种常见分类
public class Dome12 {
    public static void main(String[] args) {
        //一池一线程
        //一个窗口
        ExecutorService pool = Executors.newSingleThreadExecutor();

        //100个顾客
        try {
            for (int i = 1; i <=100 ; i++) {
                final int num =i;
                pool.execute(()->{
                    System.out.println(Thread.currentThread().getName()+"正在办理业务"+num);
                });
            }

        }catch (Exception e){
            e.printStackTrace();
        }finally {
            //关闭
            pool.shutdown();
        }

    }
}

JUC基础学习笔记_第71张图片

线程池根据需求创建线程，可以扩容，遇强则强

package myjuc;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

/**
 * @author yzh
 * @date 2024-01-10
 */
//演示线程池三种常见分类
public class Dome13 {
    public static void main(String[] args) {
        //一池可扩容线程池
        ExecutorService pool = Executors.newCachedThreadPool();


        //100个顾客
        try {
            for (int i = 1; i <=100 ; i++) {
                final int num =i;
                pool.execute(()->{
                    System.out.println(Thread.currentThread().getName()+"正在办理业务"+num);
                });
            }

        }catch (Exception e){
            e.printStackTrace();
        }finally {
            //关闭
            pool.shutdown();
        }
    }
}

JUC基础学习笔记_第72张图片

12.3线程池的底层原理及七大参数

线程池执行原理

JUC基础学习笔记_第73张图片

JUC基础学习笔记_第74张图片

  • 当线程池里存活的线程数小于核心线程数corePoolSize时，这时对于一个新提交的任务，线程池会创建一个线程去处理任务。当线程池里面存活的线程数小于等于核心线程数corePoolSize时，线程池里面的线程会一直存活着，就算空闲时间超过了keepAliveTime，线程也不会被销毁，而是一直阻塞在那里一直等待任务队列的任务来执行。
  • 当线程池里面存活的线程数已经等于corePoolSize了，这是对于一个新提交的任务，会被放进任务队列workQueue排队等待执行。
  • 当线程池里面存活的线程数已经等于corePoolSize了，并且任务队列也满了，假设maximumPoolSize>corePoolSize，这时如果再来新的任务，线程池就会继续创建新的线程来处理新的任务，知道线程数达到maximumPoolSize，就不会再创建了。
  • 如果当前的线程数达到了maximumPoolSize，并且任务队列也满了，如果还有新的任务过来，那就直接采用拒绝策略进行处理。默认的拒绝策略是抛出一个RejectedExecutionException异常。

七大参数

1、corePoolSize：当有新任务时，如果线程池中线程数没有达到线程池的基本大小，则会创建新的线程执行任务，否则将任务放入阻塞队列。当线程池中存活的线程数总是大于 corePoolSize 时，应该考虑调大 corePoolSize。

2、maximumPoolSize：当阻塞队列填满时，如果线程池中线程数没有超过最大线程数，则会创建新的线程运行任务。否则根据拒绝策略处理新任务。非核心线程类似于临时借来的资源，这些线程在空闲时间超过 keepAliveTime 之后，就应该退出，避免资源浪费。

3、BlockingQueue：存储等待运行的任务。

4、keepAliveTime：非核心线程空闲后，保持存活的时间，此参数只对非核心线程有效。设置为0，表示多余的空闲线程会被立即终止。

5、TimeUnit：时间单位

TimeUnit.DAYS
TimeUnit.HOURS
TimeUnit.MINUTES
TimeUnit.SECONDS
TimeUnit.MILLISECONDS
TimeUnit.MICROSECONDS
TimeUnit.NANOSECONDS

6、ThreadFactory：每当线程池创建一个新的线程时，都是通过线程工厂方法来完成的。在 ThreadFactory 中只定义了一个方法 newThread，每当线程池需要创建新线程就会调用它。

public class MyThreadFactory implements ThreadFactory {
    private final String poolName;
    
    public MyThreadFactory(String poolName) {
        this.poolName = poolName;
    }
    
    public Thread newThread(Runnable runnable) {
        return new MyAppThread(runnable, poolName);//将线程池名字传递给构造函数，用于区分不同线程池的线程
    }
}

7、RejectedExecutionHandler：当队列和线程池都满了的时候，根据拒绝策略处理新任务。

AbortPolicy：默认的策略，直接抛出RejectedExecutionException
DiscardPolicy：不处理，直接丢弃
DiscardOldestPolicy：将等待队列队首的任务丢弃，并执行当前任务
CallerRunsPolicy：由调用线程处理该任务

12.4自定义线程池

package myjuc;

import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.Executors;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

/**
 * @author yzh
 * @date 2024-01-10
 */
//自定义线程池
public class Dome14 {

    public static void main(String[] args) {
        ThreadPoolExecutor threadPool = new ThreadPoolExecutor(
                2,
                5,
                2L,
                TimeUnit.SECONDS,
                new ArrayBlockingQueue<>(3),
                Executors.defaultThreadFactory(),
                new ThreadPoolExecutor.AbortPolicy()
        );

        //100个顾客
        try {
            for (int i = 1; i <=100 ; i++) {
                final int num =i;
                threadPool.execute(()->{
                    System.out.println(Thread.currentThread().getName()+"正在办理业务"+num);
                });
            }

        }catch (Exception e){
            e.printStackTrace();
        }finally {
            //关闭
            threadPool.shutdown();
        }
    }
}

JUC基础学习笔记_第75张图片

出现此异常的原因：最大线程数量都被占用，等待队列也满了，拒绝策略为

AbortPolicy：默认的策略，直接抛出RejectedExecutionException

13.Fork/Join框架

Fork/Join框架是Java中用于并行计算的一种编程模型和框架。它基于"分而治之"（divide and conquer）的思想，将一个大任务划分为若干个小任务，然后将这些小任务分配给不同的线程进行执行，最后将各个子任务的结果合并得到最终结果。

Fork/Join框架主要由以下几个组成部分构成：

  1. ForkJoinPool（分支合并池）：是整个框架的核心，用于管理和调度任务的执行。它通过工作窃取（work-stealing）算法实现任务的负载均衡，即空闲的线程会主动去窃取其他线程的任务执行，以提高线程的利用率。

  2. ForkJoinTask（分支合并任务）：是任务的抽象类，可以有两种具体的子类：

    • RecursiveAction：表示没有返回值的任务。
    • RecursiveTask：表示有返回值的任务。

  3. Fork（分支）：指将一个大任务拆分成多个小任务的过程。在拆分过程中，框架会根据一定的策略将任务分配给不同的线程去执行。

  4. Join（合并）：指将多个小任务的结果合并成最终结果的过程。在合并过程中，框架会等待所有子任务完成，并将它们的结果进行合并。

使用Fork/Join框架的步骤通常包括：

  1. 继承RecursiveAction或RecursiveTask类，实现compute()方法来定义具体的任务逻辑。
  2. 在compute()方法中判断任务是否足够小，如果足够小则直接执行任务，否则将任务拆分成更小的子任务并调用fork()方法提交给线程池。
  3. 在compute()方法中使用join()方法等待子任务完成，并将子任务的结果合并得到最终结果。

Fork/Join框架可以方便地实现任务的并行执行和结果的合并，适用于处理一些需要递归拆分的问题，例如归并排序、求和等。它能够充分利用多核处理器的优势，提高程序的执行效率。

package myjuc;

import java.util.concurrent.*;

/**
 * @author yzh
 * @date 2024-01-10
 */

public class Dome15 {
    public static void main(String[] args) throws ExecutionException, InterruptedException {

        //创建MyTask对象
        MyTask task = new MyTask(0, 100);
        //创建分支合并池对象
        ForkJoinPool forkJoinPool = new ForkJoinPool();
        ForkJoinTask forkJoinTask = forkJoinPool.submit(task);
        //获取最终合并之后的结果
        Integer result = forkJoinTask.get();
        System.out.println(result);
        //关闭
        forkJoinPool.shutdown();
    }

}

class MyTask extends RecursiveTask{

    //拆分差值不能超过10,计算10以内运算
    private static final Integer VALUE=10;

    //开始值
    private int begin;
    //结束值
    private int end;
    //结果值
    private int result;

    //有参构造
    public MyTask(int begin, int end) {
        this.begin = begin;
        this.end = end;
    }

    //拆分与合并过程
    @Override
    protected Integer compute() {
        //判断相加的两个数差值是否大于10
        if (end - begin

JUC基础学习笔记_第76张图片

14.CompletableFuture异步回调

CompletableFuture是Java8中新增的一个类，它提供了一种异步编程模型，可以方便地处理异步任务并使用回调函数处理任务完成后的结果。

CompletableFuture可以看作是一个可编排的异步回调机制，它的主要特点包括：

  1. 异步执行：CompletableFuture会在后台执行异步任务，不会阻塞当前线程。

  2. 可组合性：可以通过链式调用的方式组合多个CompletableFuture，形成一个任务流水线。

  3. 回调函数：可以通过回调函数的方式处理任务完成后的结果。

  4. 异常处理：提供了异常处理的机制，可以捕获异步任务执行过程中的异常，并进行处理。

使用CompletableFuture的基本流程如下：

  1. 创建CompletableFuture对象，指定需要执行的异步任务。

  2. 注册回调函数，处理异步任务完成后的结果。

  3. 组合多个CompletableFuture，形成一个任务流水线。

  4. 获取异步任务的执行结果，或者等待所有任务执行完成后再获取结果。

package myjuc;

import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ExecutionException;

/**
 * @author yzh
 * @date 2024-01-10
 */

public class Dome16 {

    public static void main(String[] args) throws Exception {
        //异步调用没有返回值
        CompletableFuture voidCompletableFuture = CompletableFuture.runAsync(()->{
            System.out.println(Thread.currentThread().getName()+"voidCompletableFuture");
        });
        voidCompletableFuture.get();
        //异步调用有返回值
        CompletableFuture integerCompletableFuture = CompletableFuture.supplyAsync(() -> {
            System.out.println(Thread.currentThread().getName()+"integerCompletableFuture");
            //模拟异常
            int i =1/0;
            return 1024;
        });
        integerCompletableFuture.whenComplete((t,u)->{
            //方法的返回值
            System.out.println("****t"+t);
            //得到方法中的异常信息
            System.out.println("****u"+u);
        }).get();
    }
}

JUC基础学习笔记_第77张图片

你可能感兴趣的:(java,java,开发语言)

  • java工作流模式、背包模式、适配器工厂模式整合架构，让服务任务编排更便捷 窗外的寒风 适配器模式架构
    工作流和背包模式虽然不在23种常用设计模式中，但是在对任务编排处理类的业务代码使用起来是非常有用的。下面给大家介绍下工作流模式：例如，我之前有个项目需要对模型进行转换，因为不同配置的模型需要使用的转换方法不同，且单个模型需要经历多次的执行转换脚本，那就可以把每个脚本抽离出来封装为工作流中的一个字节点，通过对节点编排适应不同的转换任务，代码流程清晰，转换流程通过配置文件进行配置。背包模式呢，其实并不
  • leetcode——二叉树的最大深度（java） gentle_ice javaleetcode算法数据结构
    给定一个二叉树root，返回其最大深度。二叉树的最大深度是指从根节点到最远叶子节点的最长路径上的节点数。示例1：输入：root=[3,9,20,null,null,15,7]输出：3示例2：输入：root=[1,null,2]输出：2解题方法：（自底向上递归）1.递归入口：当前节点非空；否则，返回0；2.然后开始进入左子树递归获取左子树的深度；进入右子树递归获取右子树的深度。3.最后返回左子树与右
  • JAVA常见面试题-RabbitMQ waviss JAVA常见面试题java开发语言面试
    RabbitMQ数据类型Map：如果发送的消息类型是map类型，可以通过SerializationUtils.deserialize方法将消息转换成map类型。String（含json字符串类型）：RabbitMQ原理RabbitMQ大致分为生产者、队列、消费者，在实际情况中生产者将消息发送到Exchange（交换器），再通过Banding操作将与队列关联起来。在绑定（Banding）Exchan
  • java语句翻译_java基础语句翻译 我爱专利 java语句翻译
    publicstaticvoidmain(String[]args){System.out.println("人生中的第一个代码-----");}}package包的关键字类文件的首行位置com.zhiyou100包名；结束标志语句的结束com.zhiyou100com。zhiyou100包说明当前类HelloWorld是在com。zhiyou100包内public关键字修饰符公共的修饰符权限任何
  • Java面试题-rabbitmq-001 码者人生 面试题java技术面试题集java面试题java面试题rabbitmq
    使用RabbitMQ有什么好处？消息基于什么传输？消息怎么路由？如何做到信息的可靠性？确保消息正确地发送至RabbitMQ？确保消息接受方消费了消息？休息不丢失不重复？如何避免消息重复投递或重复消费？为什么使用集群RabbitMQ节点不完全拷贝特性集群节点类型单节点系统必须是磁盘节点?RabbitMQ要求集群中至少有一个磁盘节点?mq的缺点
  • NPM 使用介绍 lly202406 开发语言
    NPM使用介绍引言NPM（NodePackageManager）是Node.js生态系统中的一个核心工具，用于管理JavaScript项目的依赖包。无论是开发一个小型脚本还是构建大型应用程序，NPM都能极大地提高开发效率。本文将详细介绍NPM的使用方法，包括安装、配置、依赖管理、包发布等，帮助您快速上手NPM。安装NPM在开始使用NPM之前，您需要确保已经安装了Node.js。NPM与Node.j
  • 【华为机试真题JavaScript】尼科彻斯定理 forest_long 华为机试真题-JS动态规划javascriptpythonjava华为
    目录题目描述输入描述输出描述参考示例参考代码机试介绍写在最后题目描述验证尼科彻斯定理，即：任何一个整数m的立方都可以写成m个连续奇数之和。例如：1^3=12^3=3+53^3=7+9+114^3=13+15+17+19输入一个正整数m（m≤100），将m的立方写成m个连续奇数之和的形式输出。数据范围：1≤m≤100进阶：时间复杂度：O(m)，空间复杂度：O(1)输入描述输入一个int整数输出描述输
  • SpringBoot：RabbitMQ-延迟队列 csdnlaoban 程序员java-rabbitmqspringbootrabbitmq
    《一线大厂Java面试题解析+核心总结学习笔记+最新讲解视频+实战项目源码》，点击传送门，即可获取！com.alibabafastjson1.2.46org.springframework.bootspring-boot-starter-weborg.springframework.bootspring-boot-starter-testtest属性配置在application.propertie
  • java.lang.NoSuchMethodException: org.apache.catalina.deploy.WebXml addServlet 漫无目的行走的月亮
    java.lang.NoSuchMethodException:org.apache.catalina.deploy.WebXmladdServlet-------------------------------------------------------------------------------------------------------------------?解决此异常的方法是
  • Java代码-八种数组排序方法 忧郁小王子x 算法java
    一.冒泡排序1.1概述对于一组，多次将数组中的数两两比较，较大或者较小的数向后排（经过一轮比较后，最大/最小的数就会到结尾），循环直至有序排列。1.2代码实现importjava.lang.reflect.Array;importjava.util.Arrays;importjava.util.Scanner;publicclassmaopao{publicstaticvoidmain(Strin
  • 【Java】Java Lambda List转List 奔向理想的星辰大海 云原生技术研发开发语言java
    JavaLambdaList转List的实现方法引言在Java开发中，Lambda表达式是一种非常强大和常用的特性，它允许我们以一种更加简洁和灵活的方式编写代码。在处理集合类数据时，我们经常需要对列表进行转换操作，将其转换为另一种类型的列表。本文将介绍如何使用JavaLambda表达式将一个List转换为另一个List。实现步骤为了更好地理解整个过程，我们可以使用表格来展示每个步骤的具体操作。下面
  • 面向切面之集中式登录架构设计 roy_xing android架构
    普通登录流程图集中式登录流程图把共有的业务通过AOP统一管理这里我们就需要使用AspectJ来实现面向切面的集中式登录什么是AspectJAspectJ是一个面向切面的框架，它扩展了Java语言。AspectJ定义了AOP语法，它有一个专门的编译器用来生成遵守Java字节编码规范的Class文件。Aspect是切面是切入点(PointCuts)和通知(Advice)的集合。Pointcut切入点通
  • 语言模型与向量模型：深入解析与实例剖析 ♢.＊ 语言模型人工智能自然语言处理
    亲爱的小伙伴们，在求知的漫漫旅途中，若你对深度学习的奥秘、Java与Python的奇妙世界，亦或是读研论文的撰写攻略有所探寻，那不妨给我一个小小的关注吧。我会精心筹备，在未来的日子里不定期地为大家呈上这些领域的知识宝藏与实用经验分享。每一个点赞，都如同春日里的一缕阳光，给予我满满的动力与温暖，让我们在学习成长的道路上相伴而行，共同进步✨。期待你的关注与点赞哟！在自然语言处理领域，语言模型和向量模型
  • Java二维数组排序 purpleFairyx 二维数组排序比较器Lambda表达式
    今天在刷力扣的时候，有道题卡住了，没办法去看题解，发现题解是将其二维数组排序了，我才猛然发现我还不了解二位数组排序的知识。所以来记录一下。答案中的代码是这样的，假设需要排序的数组intervals：int[][]intervals={{2,3},{2,9},{4,5},{3,7},{6,7},{8,9},{1,10}};Arrays.sort(intervals,newComparator(){@
  • 【Elasticsearch 】自定义分词器 程风破～ Elasticsearchelasticsearch大数据搜索引擎
    博主简介：CSDN博客专家，历代文学网（PC端可以访问：https://literature.sinhy.com/#/?__c=1000，移动端可微信小程序搜索“历代文学”）总架构师，15年工作经验，精通Java编程，高并发设计，Springboot和微服务，熟悉Linux，ESXI虚拟化以及云原生Docker和K8s，热衷于探索科技的边界，并将理论知识转化为实际应用。保持对新技术的好奇心，乐于分
  • 如何写好C++类 铮铭 c++
    先讲一个笑话：同时学习两年Java的程序员在一起讨论的是面向对象和设计模式，而同时学习两年C++的程序员，在一起讨论的是template和各种语言规范到底怎么回事情。下面就从公开的资料中撸一撸如何写好一个c++类，从头文件（.h）需要包含的文件开始：1、#define保护：符号的命名最好是以下形式：___H_，比如foo项目中的foo/src/bar/baz.h文件应该这样保护：#ifndefFO
  • IDEA+Java+SSH+Bootstrap+Mysql实现在线考试系统(含论文) 2401_89694162 javaintellij-ideassh
    –Recordsoft_managerINSERTINTOt_managerVALUES(1,‘管理员’,‘admin’,‘admin’);–Tablestructurefort_paperDROPTABLEIFEXISTSt_paper;CREATETABLEt_paper(idint(11)NOTNULLAUTO_INCREMENT,joinDatedatetime(0)NULLDEFAULT
  • Python 调用常见大模型 API 全解析 ♢.＊ python开发语言语言模型nlp
    亲爱的小伙伴们，在求知的漫漫旅途中，若你对深度学习的奥秘、JAVA、PYTHON与SAP的奇妙世界，亦或是读研论文的撰写攻略有所探寻，那不妨给我一个小小的关注吧。我会精心筹备，在未来的日子里不定期地为大家呈上这些领域的知识宝藏与实用经验分享。每一个点赞，都如同春日里的一缕阳光，给予我满满的动力与温暖，让我们在学习成长的道路上相伴而行，共同进步✨。期待你的关注与点赞哟！调用通义千问接口获取APIKe
  • java FastJSON自定义序列化和反序列化(扩展点)方法总结！10个步骤让你轻松掌握 墨瑾轩 一起学学Java【一】开发语言java
    关注墨瑾轩，带你探索编程的奥秘！超萌技术攻略，轻松晋级编程高手技术宝库已备好，就等你来挖掘订阅墨瑾轩，智趣学习不孤单即刻启航，编程之旅更有趣嘿，小伙伴们！今天我们要一起探讨一个非常实用的话题——如何使用FastJSON自定义序列化和反序列化。你知道吗？FastJSON是阿里巴巴开源的一个高性能JSON库，广泛应用于Java项目中。虽然FastJSON提供了丰富的内置功能，但有时候我们还需要根据具体
  • java编程根据订单编号查询订单状态_java生成订单编号工具 赖明星
    直接code，用了线程执行，加上了锁publicclassTestOrderextendsThread{privatestaticlongorderNum=0l;privatestaticStringdate;publicstaticvoidmain(String[]args)throwsInterruptedException{for(inti=0;i<10000;i++){System.out
  • 【课程设计推荐】基于JSP的论文格式化系统后台模块的设计与实现 想念@思恋 课程设计jspjava课程设计javajsp
    关注【墨岚创客】，回复【毕设】，赠送免费毕设资源，具体联系方式见文末摘要论文的格式修改是一件很麻烦的事情，一篇论文在定稿以前为了让格式达到标准，需要修改很多次，浪费了大量时间。本系统的设计初衷就是为了解决论文书写格式的规范化，方便学者论文格式的自动生成。本系统是基于Java平台的Web应用程序。采用JSP作为后台开发语言，HTML和JavaScript作为前台开发语言，MYSQL5.0作为后台数据
  • Java获取时区 松间藏雪 java开发语言后端
    1.TimeZone.getDefault()TimeZonetimeZone=TimeZone.getDefault();System.out.println(timeZone.getDisplayName());System
  • javascript使用字符串作为参数报错的问题 jumptigerfu 前端问题&解决方案elementui前端flaskjavascriptpython
    原因:因为直接字符串作为参数需要加单引号,不然就判定为为定义的参数functionoption(value,row,index){varhtm="";htm+='导入'returnhtm;}解决方案:onclick里面加入转义字符\'functionoption(value,row,index){varhtm="";htm+='导入'returnhtm;}完美解决
  • Vue 响应式渲染 - 模板语法 JSON_L 前端#Vuevue.js前端javascript
    Vue渐进式JavaScript框架基于Vue2的学习笔记-Vue响应式渲染-模板语法目录模板语法渲染变量（状态）绑定事件简写事件修改属性样式修改绑定图片路径动态显示和隐藏总结模板语法渲染变量（状态）在页面中直接渲染变量。示例如下：Title{{myname}}newVue({el:"#box",//elementdata:{myname:'我的名字是张三'}})绑定事件增加按钮，并对按钮绑定点击
  • java笔记--设计模式之装饰模式 2401_89693697 java笔记设计模式
    packagecom.example.design.decorate;publicclassConcreteComponentimplementsComponent{@OverridepublicvoiddoThingA(){//TODO自动生成的方法存根System.out.println("具体构件实现的抽象接口，dothingA");}}(3)装饰类角色packagecom.example.
  • Java Web 网络商城案例演示十四（设计订单表）(3) 2401_84006757 程序员java前端windows
    创建Order{Useruser,Listlist=newArrayList}publicclassOrder{privateStringoid;//订单编号privateDateordertime;//下单时间privatedoubletotal;//总计privateintstate;//状态privateStringaddress;//收货人地址privateStringname;//收货人
  • 解决 Lombok 与 Java 模块系统的兼容性问题：从错误到解决方案 码农阿豪@新空间代码工作室 包罗万象java开发语言
    个人名片作者简介：java领域优质创作者个人主页：码农阿豪工作室：新空间代码工作室（提供各种软件服务)个人邮箱：[[email protected]]个人微信：15279484656个人导航网站：www.forff.top座右铭：总有人要赢。为什么不能是我呢？专栏导航：码农阿豪系列专栏导航面试专栏：收集了java相关高频面试题，面试实战总结️Spring5系列专栏：整理了Spring5重要知识点与
  • 【uniapp】uniapp使用java线程池 新青年. uni-appjavascript
    标题由于js是性能孱弱的单线程语言，只要在渲染中执行了一些其他操作，会中断渲染，导致页面卡死，卡顿，吐司不消失等问题。在安卓端可以调用java线程池，把耗时操作写入线程池里面，优化性能。实现使用native.js,直接贴出代码classJavaExecutorPool{constructor(){//#ifdefAPP-PLUSconstScheduledThreadPoolExecutor=pl
  • Python中使用SQLite 昂热校长
    开发十年，就只剩下这套Java开发体系了>>>SQLite：SQLite是一种数据库，Python中集成了SQLite3，所以在Python中使用SQLite，可以直接导入SQLite包，不需要做额外的配置。更多的SQLite简介和相关知识可以查看专门的教程：http://www.runoob.com/sqlite/sqlite-tutorial.htmlPython中使用SQLite:可以直接像
  • 深入探讨：服务器如何响应前端请求及后端如何查看前端提交的数据 我的青春不太冷 服务器前端运维
    深入探讨：服务器如何响应前端请求及后端如何查看前端提交的数据一、服务器如何响应前端请求前端与后端的交互主要通过HTTP协议实现。以下是详细步骤：1.前端发起HTTP请求GET请求：用于从服务器获取数据。POST请求：用于向服务器提交数据。例如，使用JavaScript的fetchAPI发送POST请求：fetch('https://example.com/api/data',{method:'PO
  • 矩阵求逆（JAVA）初等行变换 qiuwanchi 矩阵求逆（JAVA）
    package gaodai.matrix; import gaodai.determinant.DeterminantCalculation; import java.util.ArrayList; import java.util.List; import java.util.Scanner; /** * 矩阵求逆(初等行变换) * @author 邱万迟 *
  • JDK timer antlove javajdkschedulecodetimer
    1.java.util.Timer.schedule(TimerTask task, long delay)：多长时间（毫秒）后执行任务 2.java.util.Timer.schedule(TimerTask task, Date time)：设定某个时间执行任务 3.java.util.Timer.schedule(TimerTask task, long delay,longperiod
  • JVM调优总结 -Xms -Xmx -Xmn -Xss coder_xpf jvm应用服务器
    堆大小设置JVM 中最大堆大小有三方面限制：相关操作系统的数据模型（32-bt还是64-bit）限制；系统的可用虚拟内存限制；系统的可用物理内存限制。32位系统下，一般限制在1.5G~2G；64为操作系统对内存无限制。我在Windows Server 2003 系统，3.5G物理内存，JDK5.0下测试，最大可设置为1478m。 典型设置： java -Xmx
  • JDBC连接数据库 Array_06 jdbc
    package Util; import java.sql.Connection; import java.sql.DriverManager; import java.sql.ResultSet; import java.sql.SQLException; import java.sql.Statement; public class JDBCUtil { //完
  • Unsupported major.minor version 51.0（jdk版本错误） oloz java
    java.lang.UnsupportedClassVersionError: cn/support/cache/CacheType : Unsupported major.minor version 51.0 (unable to load class cn.support.cache.CacheType) at org.apache.catalina.loader.WebappClassL
  • 用多个线程处理1个List集合 362217990 多线程threadlist集合
      昨天发了一个提问，启动5个线程将一个List中的内容，然后将5个线程的内容拼接起来，由于时间比较急迫，自己就写了一个Demo，希望对菜鸟有参考意义。。 import java.util.ArrayList; import java.util.List; import java.util.concurrent.CountDownLatch; public c
  • JSP简单访问数据库 香水浓 sqlmysqljsp
    学习使用javaBean，代码很烂，仅为留个脚印 public class DBHelper { private String driverName; private String url; private String user; private String password; private Connection connection; privat
  • Flex4中使用组件添加柱状图、饼状图等图表 AdyZhang Flex
    1.添加一个最简单的柱状图 ? 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 <?xml version= "1.0"&n
  • Android 5.0 - ProgressBar 进度条无法展示到按钮的前面 aijuans android
    在低于SDK < 21 的版本中，ProgressBar 可以展示到按钮前面，并且为之在按钮的中间，但是切换到android 5.0后进度条ProgressBar 展示顺序变化了，按钮再前面，ProgressBar 在后面了我的xml配置文件如下：   [html]  view plain copy   <RelativeLa
  • 查询汇总的sql baalwolf sql
    select   list.listname, list.createtime,listcount from dream_list as list ,   (select listid,count(listid) as listcount  from dream_list_user  group by listid  order by count(
  • Linux du命令和df命令区别 BigBird2012 linux
            1，两者区别             du，disk usage,是通过搜索文件来计算每个文件的大小然后累加，du能看到的文件只是一些当前存在的，没有被删除的。他计算的大小就是当前他认为存在的所有文件大小的累加和。        
  • AngularJS中的$apply，用还是不用？ bijian1013 JavaScriptAngularJS$apply
            在AngularJS开发中，何时应该调用$scope.$apply()，何时不应该调用。下面我们透彻地解释这个问题。         但是首先，让我们把$apply转换成一种简化的形式。         scope.$apply就像一个懒惰的工人。它需要按照命
  • [Zookeeper学习笔记十]Zookeeper源代码分析之ClientCnxn数据序列化和反序列化 bit1129 zookeeper
    ClientCnxn是Zookeeper客户端和Zookeeper服务器端进行通信和事件通知处理的主要类，它内部包含两个类，1. SendThread 2. EventThread， SendThread负责客户端和服务器端的数据通信，也包括事件信息的传输，EventThread主要在客户端回调注册的Watchers进行通知处理   ClientCnxn构造方法   &
  • 【Java命令一】jmap bit1129 Java命令
    jmap命令的用法：   [hadoop@hadoop sbin]$ jmap Usage: jmap [option] <pid> (to connect to running process) jmap [option] <executable <core> (to connect to a
  • Apache 服务器安全防护及实战 ronin47
    此文转自IBM. Apache 服务简介 Web 服务器也称为 WWW 服务器或 HTTP 服务器 (HTTP Server)，它是 Internet 上最常见也是使用最频繁的服务器之一，Web 服务器能够为用户提供网页浏览、论坛访问等等服务。 由于用户在通过 Web 浏览器访问信息资源的过程中，无须再关心一些技术性的细节，而且界面非常友好，因而 Web 在 Internet 上一推出就得到
  • unity 3d实例化位置出现布置？ brotherlamp unity教程unityunity资料unity视频unity自学
    问：unity 3d实例化位置出现布置？ 答：实例化的同时就可以指定被实例化的物体的位置,即 position  Instantiate (original : Object, position : Vector3, rotation : Quaternion) : Object 这样你不需要再用Transform.Position了,   如果你省略了第二个参数(
  • 《重构，改善现有代码的设计》第八章 Duplicate Observed Data bylijinnan java重构
    import java.awt.Color; import java.awt.Container; import java.awt.FlowLayout; import java.awt.Label; import java.awt.TextField; import java.awt.event.FocusAdapter; import java.awt.event.FocusE
  • struts2更改struts.xml配置目录 chiangfai struts.xml
    struts2默认是读取classes目录下的配置文件，要更改配置文件目录，比如放在WEB-INF下，路径应该写成../struts.xml(非/WEB-INF/struts.xml) web.xml文件修改如下：   <filter> <filter-name>struts2</filter-name> <filter-class&g
  • redis做缓存时的一点优化 chenchao051 redishadooppipeline
            最近集群上有个job，其中需要短时间内频繁访问缓存，大概7亿多次。我这边的缓存是使用redis来做的，问题就来了。       首先，redis中存的是普通kv，没有考虑使用hash等解结构，那么以为着这个job需要访问7亿多次redis，导致效率低，且出现很多redi
  • mysql导出数据不输出标题行 daizj mysql数据导出去掉第一行去掉标题
    当想使用数据库中的某些数据，想将其导入到文件中，而想去掉第一行的标题是可以加上-N参数 如通过下面命令导出数据： mysql -uuserName -ppasswd -hhost -Pport -Ddatabase -e " select * from tableName"  > exportResult.txt 结果为： studentid
  • phpexcel导出excel表简单入门示例 dcj3sjt126com PHPExcelphpexcel
    先下载PHPEXCEL类文件，放在class目录下面，然后新建一个index.php文件，内容如下 <?php error_reporting(E_ALL); ini_set('display_errors', TRUE); ini_set('display_startup_errors', TRUE);   if (PHP_SAPI == 'cli') die('
  • 爱情格言 dcj3sjt126com 格言
     1) I love you not because of who you are, but because of who I am when I am with you. 　　 我爱你，不是因为你是一个怎样的人，而是因为我喜欢与你在一起时的感觉。 　　2) No man or woman is worth your tears, and the one who is, won‘t
  • 转 Activity 详解——Activity文档翻译 e200702084 androidUIsqlite配置管理网络应用
    activity 展现在用户面前的经常是全屏窗口，你也可以将 activity 作为浮动窗口来使用（使用设置了 windowIsFloating 的主题），或者嵌入到其他的 activity （使用 ActivityGroup ）中。 当用户离开 activity 时你可以在 onPause() 进行相应的操作 。更重要的是，用户做的任何改变都应该在该点上提交 ( 经常提交到 ContentPro
  • win7安装MongoDB服务 geeksun mongodb
    1.  下载MongoDB的windows版本：mongodb-win32-x86_64-2008plus-ssl-3.0.4.zip，Linux版本也在这里下载，下载地址： http://www.mongodb.org/downloads   2.  解压MongoDB在D:\server\mongodb, 在D:\server\mongodb下创建d
  • Javascript魔法方法:__defineGetter__,__defineSetter__ hongtoushizi js
    转载自： http://www.blackglory.me/javascript-magic-method-definegetter-definesetter/ 在javascript的类中,可以用defineGetter和defineSetter_控制成员变量的Get和Set行为 例如,在一个图书类中,我们自动为Book加上书名符号: function Book(name){
  • 错误的日期格式可能导致走nginx proxy cache时不能进行304响应 jinnianshilongnian cache
    昨天在整合某些系统的nginx配置时，出现了当使用nginx cache时无法返回304响应的情况，出问题的响应头： Content-Type:text/html; charset=gb2312 Date:Mon, 05 Jan 2015 01:58:05 GMT Expires:Mon , 05 Jan 15 02:03:00 GMT Last-Modified:Mon, 05
  • 数据源架构模式之行数据入口 home198979 PHP架构行数据入口
    注：看不懂的请勿踩，此文章非针对java，java爱好者可直接略过。   一、概念 行数据入口（Row Data Gateway）：充当数据源中单条记录入口的对象，每行一个实例。   二、简单实现行数据入口 为了方便理解，还是先简单实现： <?php /** * 行数据入口类 */ class OrderGateway { /*定义元数
  • Linux各个目录的作用及内容 pda158 linux脚本
    1）根目录“/” 　　根目录位于目录结构的最顶层，用斜线（/）表示，类似于 Windows 操作系统的“C:\“，包含Fedora操作系统中所有的目录和文件。 　　2）/bin 　　/bin 　　目录又称为二进制目录，包含了那些供系统管理员和普通用户使用的重要 linux命令的二进制映像。该目录存放的内容包括各种可执行文件，还有某些可执行文件的符号连接。常用的命令有：cp、d
  • ubuntu12.04上编译openjdk7 ol_beta HotSpotjvmjdkOpenJDK
    获取源码 从openjdk代码仓库获取(比较慢) 安装mercurial Mercurial是一个版本管理工具。 sudo apt-get install mercurial 将以下内容添加到$HOME/.hgrc文件中，如果没有则自己创建一个： [extensions] forest=/home/lichengwu/hgforest-crew/forest.py fe
  • 将数据库字段转换成设计文档所需的字段 vipbooks 设计模式工作正则表达式
            哈哈，出差这么久终于回来了，回家的感觉真好！         PowerDesigner的物理数据库一出来，设计文档中要改的字段就多得不计其数，如果要把PowerDesigner中的字段一个个Copy到设计文档中，那将会是一件非常痛苦的事情。
按字母分类： ABCDEFGHIJKLMNOPQRSTUVWXYZ其他