JAVA里的多线程综合练习题

news2025/1/13 15:53:36

练习1

package lx1;

/*一共有1000张电影票,可以在两个窗口领取,假设每次领取的时间为3000毫秒,
要求:请用多线程模拟卖票过程并打印剩余电影票的数量*/
public class MyThread extends Thread {
    static int ticket = 1000;//多个线程对象共享同一个电影票

    //第一种方式实现多线程，测试类中MyThread会创建多次，所以需要加stat
    @Override
    public void run() {
        //1.循环
        while (true) {
            //2.同步代码块
            synchronized (MyThread.class) {
                //3.判断共享数据（已经到末尾）
                if (ticket == 0) {
                    break;
                } else {
                    //4.判断共享数据（没有到末尾）
                    try {
                        Thread.sleep(3000);
                    } catch (InterruptedException e) {
                        throw new RuntimeException(e);
                    }
                    ticket--;
                    System.out.println(getName() + "在卖票，还剩下" + ticket + "张票!!!");
                }
            }
        }

    }
}

package lx1;

public class demo1 {
    public static void main(String[] args) {
/*
            一共有1000张电影票,可以在两个窗口领取,假设每次领取的时间为3000毫秒,
            要求:请用多线程模拟卖票过程并打印剩余电影票的数量
        */


        //1.创建多线程
        MyThread t1 = new MyThread();
        MyThread t2 = new MyThread();
        t1.setName("窗口1");
        t2.setName("窗口2");
        //2.启动线程
        t1.start();
        t2.start();
    }
}

练习2

package lx2;

/*
有100份礼品,两人同时发送，当剩下的礼品小于10份的时候则不再送出，
利用多线程模拟该过程并将线程的名字和礼物的剩余数量打印出来.
 */
public class MyThread extends Thread {
    static int liping = 100;

    @Override
    public void run() {
        //1.循环
        while (true) {
            //2.同步代码块
            synchronized (MyThread.class) {
                //3.判断共享数据(已经到了末尾）
                if (liping == 0) {
                    break;
                } else {
                    //4.判断共享数据（没有到末尾）
                    //当剩下的礼品小于10份的时候则不再送出
                    try {
                        Thread.sleep(00);
                    } catch (InterruptedException e) {
                        throw new RuntimeException(e);
                    }
                    if (liping < 10) {
                        break;
                    }
                    liping--;
                    System.out.println(getName() + "还剩余" + liping + "份礼品");

                }


            }
        }
    }
}

package lx2;

public class demo1 {
    public static void main(String[] args) {
          /*
            有100份礼品,两人同时发送，当剩下的礼品小于10份的时候则不再送出，
            利用多线程模拟该过程并将线程的名字和礼物的剩余数量打印出来.
        */
        //1,创建多线程对象
        MyThread t1 = new MyThread();

        MyThread t2 = new MyThread();
        t1.setName("小明");
        t2.setName("小华");
        //2.启动线程
        t1.start();
        t2.start();

    }
}

练习3

package lx3;

/*
          同时开启两个线程，共同获取1-100之间的所有数字。
          要求：将输出所有的奇数。
       */
public class MyRunable implements Runnable {
    //采用第二种方式实现多线程 不需要加上static修饰 因为创建的线程对象是MyRunable的实例对象，而实例对象是唯一的
    int number = 1;

    @Override
    public void run() {
        //1.循环
        while (true) {

            //2.同步代码块
            synchronized (MyRunable.class) {
                //3.判断共享数据（已经到末尾）
                if (number > 100) {
                    break;
                } else {
                    //4.判断共享数据（还没有到末尾）
                    if (number % 2 == 1) {
                        System.out.println(Thread.currentThread().getName() + "打印数字" + number);

                    }
                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        throw new RuntimeException(e);
                    }
                    number++;
                }
            }
        }

    }
}

package lx3;

public class Test {
    public static void main(String[] args) {
        /*
           同时开启两个线程，共同获取1-100之间的所有数字。
           要求：将输出所有的奇数。
        */


        //创建多线程对象，表示多线程要执行的任务
        MyRunable mr = new MyRunable();
        Thread t1 = new Thread(mr);

        Thread t2 = new Thread(mr);
        t1.setName("线程1");
        t2.setName("线程2");
        //启动线程
        t1.start();
        t2.start();


    }
}

 

练习4

package lx4;

import java.util.Random;

/*
           微信中的抢红包也用到了多线程。
           假设：100块，分成了3个包，现在有5个人去抢。
           其中，红包是共享数据。
           5个人是5条线程。
           打印结果如下：
               XXX抢到了XXX元
               XXX抢到了XXX元
               XXX抢到了XXX元
               XXX没抢到
               XXX没抢到
       */
public class Mythread extends Thread {
    //共享数据
    //100块，分成了3个包
    static double money = 100;
    static int count = 3;
    //设置最小的中奖金额
    static final double MIN = 0.01;

    @Override
    public void run() {
        //同步代码块
        synchronized (Mythread.class) {
            //判断共享数据是否到了末尾（已经到了末尾）
            if (count == 0) {
                System.out.println(getName() + "没有抢到红包！");
            } else {
                /*
                不能随机随机
                现在有100元
                第一次随机从100里面随机一个金额 比如说50
                第二次随机就要从剩下来的50元里面随机  比如说30
                第三次随机就直接把剩下的的20元当做抽取到的红包即可 没必要随机了
                 */
                //判断共享数据是否到了末尾（还没有到了末尾）

                //定义一个变量，表示抽到红包的金额
                double price = 0;
                if (count == 1) {
                    //表示最后一个红包
                    //就无需随机 ，剩下的所有的钱都是中奖金额
                    price = money;
                } else {
                    //表示第一次或者第二次抽取红包（随机）
                    Random r = new Random();
                    //现在有100元  3个红包
                    //第一次最多抽取99.98 因为还剩下2个红包要抽取，最小金额是0.01元
                    //100-(3-1）*0.01=99.98
                    double bounds = money - (count - 1) * MIN;
                    price = r.nextDouble(bounds) + MIN;//不包括抽取金额为0 所以加上最小金额0.01  0.01-99.99 不包括99.99

                }
                //从money当中，去掉当前中奖的金额
                money -= price;
                //红包的个数-1
                count--;
                //本次红包的信息进行打印
                System.out.println(getName() + "抢到了" + price + "元");
            }
        }

    }
}


package lx4;

public class Test {
    public static void main(String[] args) {
         /*
            微信中的抢红包也用到了多线程。
            假设：100块，分成了3个包，现在有5个人去抢。
            其中，红包是共享数据。
            5个人是5条线程。
            打印结果如下：
            	XXX抢到了XXX元
            	XXX抢到了XXX元
            	XXX抢到了XXX元
            	XXX没抢到
            	XXX没抢到
        */
        //一次线程只能执行一次完整的run方法
        Mythread t1 = new Mythread();
        Mythread t2 = new Mythread();
        Mythread t3 = new Mythread();
        Mythread t4 = new Mythread();
        Mythread t5 = new Mythread();
        t1.setName("张三");
        t2.setName("王五");
        t3.setName("李四");
        t4.setName("赵六");
        t5.setName("小小");

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


    }
}

练习5

package lx5;
/*
            有一个抽奖池,该抽奖池中存放了奖励的金额,该抽奖池中的奖项为 {10,5,20,50,100,200,500,800,2,80,300,700};
            创建两个抽奖箱(线程)设置线程名称分别为“抽奖箱1”，“抽奖箱2”
            随机从抽奖池中获取奖项元素并打印在控制台上,格式如下:
                             每次抽出一个奖项就打印一个(随机)
            	抽奖箱1 又产生了一个 10 元大奖
            	抽奖箱1 又产生了一个 100 元大奖
            	抽奖箱1 又产生了一个 200 元大奖
            	抽奖箱1 又产生了一个 800 元大奖
            	抽奖箱2 又产生了一个 700 元大奖
            	.....
        */

import java.util.ArrayList;
import java.util.Collections;

public class MyThread extends Thread {
    //共享数据
    // 奖励的金额
    ArrayList<Integer> list;

    public MyThread(ArrayList<Integer> list) {
        this.list = list;
    }
/*
我们采用随机抽一个删一个的方法
 */

    @Override
    public void run() {
        //1.循环
        while (true) {

            //同步代码块
            synchronized (MyThread.class) {
                //判断共享数据是否到了末尾（到了末尾）
                if (list.size() == 0) {
                    break;
                } else {
                    //判断共享数据是否到了末尾（还没有到末尾）
                    //随机一个删一个
                    Collections.shuffle(list);
                    int index = list.get(0);
                    System.out.println(getName() + "又产生了一个" + index + "元大奖");

                    list.remove(0);

                }
            }
            /*
            把sleep代码写在锁的外面
            因为当线程1进去了，如果你sleep写在锁里面，导致线程1睡了，线程2就无法进入锁了。
            写在外面，线程1执行完了，锁就开了，线程1睡100ms 线程2就有机会抢到cpu执行权
             */
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        }

    }
}

package lx5;

import java.util.ArrayList;
import java.util.Collections;

public class Test {
    public static void main(String[] args) {
        /*
            有一个抽奖池,该抽奖池中存放了奖励的金额,该抽奖池中的奖项为 {10,5,20,50,100,200,500,800,2,80,300,700};
            创建两个抽奖箱(线程)设置线程名称分别为“抽奖箱1”，“抽奖箱2”
            随机从抽奖池中获取奖项元素并打印在控制台上,格式如下:
                             每次抽出一个奖项就打印一个(随机)
            	抽奖箱1 又产生了一个 10 元大奖
            	抽奖箱1 又产生了一个 100 元大奖
            	抽奖箱1 又产生了一个 200 元大奖
            	抽奖箱1 又产生了一个 800 元大奖
            	抽奖箱2 又产生了一个 700 元大奖
            	.....
        */

        //创建抽奖箱奖池
        ArrayList<Integer> list=new ArrayList<>();
        Collections.addAll(list,10,5,20,50,100,200,500,800,2,80,300,700);
        MyThread t1=new MyThread(list);
        MyThread t2=new MyThread(list);
        t1.setName("抽奖箱1");
        t2.setName("抽奖箱2");
        t1.start();
        t2.start();



    }
}

 

练习6

方法1 

package lx6;
 /*
            有一个抽奖池,该抽奖池中存放了奖励的金额,该抽奖池中的奖项为 {10,5,20,50,100,200,500,800,2,80,300,700};
            创建两个抽奖箱(线程)设置线程名称分别为“抽奖箱1”，“抽奖箱2”
            随机从抽奖池中获取奖项元素并打印在控制台上,格式如下:
            每次抽的过程中，不打印，抽完时一次性打印(随机)    在此次抽奖过程中，抽奖箱1总共产生了6个奖项。
                分别为：10,20,100,500,2,300最高奖项为300元，总计额为932元
            在此次抽奖过程中，抽奖箱2总共产生了6个奖项。
                分别为：5,50,200,800,80,700最高奖项为800元，总计额为1835元
        */

import java.util.ArrayList;
import java.util.Collections;

public class MyThread extends Thread {
    //共享数据
    // 奖励的金额
    ArrayList<Integer> list;

    public MyThread(ArrayList<Integer> list) {
        this.list = list;
    }

    //线程1的
    static ArrayList<Integer> list1 = new ArrayList<>();
    //线程2的
    static ArrayList<Integer> list2 = new ArrayList<>();
/*
我们采用随机抽一个删一个的方法
 */

    @Override
    public void run() {
        //1.循环
        while (true) {

            //同步代码块
            synchronized (MyThread.class) {
                //判断共享数据是否到了末尾（到了末尾）

                if (list.size() == 0) {

                    break;
                } else {
                    //判断共享数据是否到了末尾（还没有到末尾）
                    //随机一个删一个
                    Collections.shuffle(list);
                    int index = list.get(0);
                    //  System.out.println(getName() + "又产生了一个" + index + "元大奖");

                    list.remove(0);
                    if ("抽奖箱1".equals(getName())) {
                        list1.add(index);
                    } else {
                        list2.add(index);
                    }

                }

            }
            /*
            把sleep代码写在锁的外面
            因为当线程1进去了，如果你sleep写在锁里面，导致线程1睡了，线程2就无法进入锁了。
            写在外面，线程1执行完了，锁就开了，线程1睡100ms 线程2就有机会抢到cpu执行权
             */
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        }
        int sum1 = 0;
        int max1 = 0;
        for (Integer i : list1) {
            sum1 += i;
            if (max1 < i) {

                max1 = i;
            }

        }
        int sum2 = 0;
        int max2 = 0;
        for (Integer i : list2) {
            sum2 += i;
            if (max2 < i) {

                max2 = i;
            }

        }
        if ("抽奖箱1".equals(getName())) {
            System.out.println(getName() + list1 + "最高奖项为" + max1 + "元，总计额为" + sum1 + "元");
        } else {
            System.out.println(getName() + list2 + "最高奖项为" + max2 + "元，总计额为" + sum2 + "元");
        }

    }


}

package lx6;

import java.util.ArrayList;
import java.util.Collections;

public class Test {
    public static void main(String[] args) {
       /*
            有一个抽奖池,该抽奖池中存放了奖励的金额,该抽奖池中的奖项为 {10,5,20,50,100,200,500,800,2,80,300,700};
            创建两个抽奖箱(线程)设置线程名称分别为“抽奖箱1”，“抽奖箱2”
            随机从抽奖池中获取奖项元素并打印在控制台上,格式如下:
            每次抽的过程中，不打印，抽完时一次性打印(随机)    在此次抽奖过程中，抽奖箱1总共产生了6个奖项。
                分别为：10,20,100,500,2,300最高奖项为300元，总计额为932元
            在此次抽奖过程中，抽奖箱2总共产生了6个奖项。
                分别为：5,50,200,800,80,700最高奖项为800元，总计额为1835元
        */

        //创建抽奖箱奖池
        ArrayList<Integer> list=new ArrayList<>();
        Collections.addAll(list,10,5,20,50,100,200,500,800,2,80,300,700);
        MyThread t1=new MyThread(list);
        MyThread t2=new MyThread(list);
        t1.setName("抽奖箱1");
        t2.setName("抽奖箱2");
        t1.start();
        t2.start();



    }
}

 

每个线程都有自己独立的栈空间 

run方法里的集合是独立的，互相独立的

方法2

把集合的创建放在run方法里面，每个线程都会执行run方法，创建出不同空间的集合

package lx7;
 /*
            有一个抽奖池,该抽奖池中存放了奖励的金额,该抽奖池中的奖项为 {10,5,20,50,100,200,500,800,2,80,300,700};
            创建两个抽奖箱(线程)设置线程名称分别为“抽奖箱1”，“抽奖箱2”
            随机从抽奖池中获取奖项元素并打印在控制台上,格式如下:
            每次抽的过程中，不打印，抽完时一次性打印(随机)    在此次抽奖过程中，抽奖箱1总共产生了6个奖项。
                分别为：10,20,100,500,2,300最高奖项为300元，总计额为932元
            在此次抽奖过程中，抽奖箱2总共产生了6个奖项。
                分别为：5,50,200,800,80,700最高奖项为800元，总计额为1835元
        */

import java.util.ArrayList;
import java.util.Collections;

public class MyThread extends Thread {
    //共享数据
    // 奖励的金额
    ArrayList<Integer> list;

    public MyThread(ArrayList<Integer> list) {
        this.list = list;
    }


/*
我们采用随机抽一个删一个的方法
 */

    @Override
    public void run() {
        //创建集合 存放抽奖的奖项 这些集合都是根据线程的创建而创建的 就是每个线程创建一个集合
        ArrayList<Integer> boxList = new ArrayList<>();
        //1.循环
        while (true) {

            //同步代码块
            synchronized (MyThread.class) {
                //判断共享数据是否到了末尾（到了末尾）

                if (list.size() == 0) {
                    break;
                } else {
                    //判断共享数据是否到了末尾（还没有到末尾）
                    //随机一个删一个
                    Collections.shuffle(list);
                    int index = list.get(0);
                    list.remove(0);
                    //每个线程对对应的集合添加元素（集合不同）
                    boxList.add(index);

                }

            }
            /*
            把sleep代码写在锁的外面
            因为当线程1进去了，如果你sleep写在锁里面，导致线程1睡了，线程2就无法进入锁了。
            写在外面，线程1执行完了，锁就开了，线程1睡100ms 线程2就有机会抢到cpu执行权
             */
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        }
        int sum = 0;
        int max = 0;
        for (Integer i : boxList) {
            sum += i;
            if (max < i) {

                max = i;
            }

        }
        //这里看起来只是打印一个集合，本质上是根据线程的多少打印出不同的集合
        System.out.println(getName() + boxList + "最高奖项为" + max + "元，总计额为" + sum + "元");


    }


}


package lx7;
import java.util.ArrayList;
import java.util.Collections;

public class Test {
    public static void main(String[] args) {
        /*
            有一个抽奖池,该抽奖池中存放了奖励的金额,该抽奖池中的奖项为 {10,5,20,50,100,200,500,800,2,80,300,700};
            创建两个抽奖箱(线程)设置线程名称分别为“抽奖箱1”，“抽奖箱2”
            随机从抽奖池中获取奖项元素并打印在控制台上,格式如下:
            每次抽的过程中，不打印，抽完时一次性打印(随机)    在此次抽奖过程中，抽奖箱1总共产生了6个奖项。
                分别为：10,20,100,500,2,300最高奖项为300元，总计额为932元
            在此次抽奖过程中，抽奖箱2总共产生了6个奖项。
                分别为：5,50,200,800,80,700最高奖项为800元，总计额为1835元
        */

        //创建抽奖箱奖池
        ArrayList<Integer> list=new ArrayList<>();
        Collections.addAll(list,10,5,20,50,100,200,500,800,2,80,300,700);
        MyThread t1=new MyThread(list);
        MyThread t2=new MyThread(list);
        MyThread t3=new MyThread(list);
        t1.setName("抽奖箱1");
        t2.setName("抽奖箱2");
        t3.setName("抽奖箱3");

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

这个方法强调的是每个线程创建出不同的集合，每个线程都有自己的集合

练习7

package lx8;


import java.util.ArrayList;
import java.util.Collections;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;

public class Test {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
           /*
            有一个抽奖池,该抽奖池中存放了奖励的金额,该抽奖池中的奖项为 {10,5,20,50,100,200,500,800,2,80,300,700};
            创建两个抽奖箱(线程)设置线程名称分别为    "抽奖箱1", "抽奖箱2"
            随机从抽奖池中获取奖项元素并打印在控制台上,格式如下:
            在此次抽奖过程中，抽奖箱1总共产生了6个奖项，分别为：10,20,100,500,2,300
        	    最高奖项为300元，总计额为932元
            在此次抽奖过程中，抽奖箱2总共产生了6个奖项，分别为：5,50,200,800,80,700
            	最高奖项为800元，总计额为1835元

            在此次抽奖过程中,抽奖箱2中产生了最大奖项,该奖项金额为800元
            核心逻辑：获取线程抽奖的最大值（看成是线程运行的结果）

            以上打印效果只是数据模拟,实际代码运行的效果会有差异
        */
//创建抽奖箱奖池
        ArrayList<Integer> list = new ArrayList<>();
        Collections.addAll(list, 10, 5, 20, 50, 100, 200, 500, 800, 2, 80, 300, 700);

        /*
         1.定义一个类MyCallable实现Callable接口
        2.在MyCallable类中重写call()方法  有返回值的表示多线程运行的结果
        3.创建MyCallable类的对象 表示多线程要执行的任务
        4.创建Future的实现类FutureTask对象，把MyCallable对象作为构造方法的参数  作用：管理多线程运行的结果
        5.创建Thread类的对象，把FutureTask对象作为构造方法的参数 表示线程
        6.启动线程
        7.再调用get方法，就可以获取线程结束之后的结果。
         */
        Mycallable m = new Mycallable(list);
        FutureTask<Integer> ft = new FutureTask<>(m);
        Thread t1 = new Thread(ft);
        Thread t2 = new Thread(ft);
        t1.setName("抽奖箱1");
        t2.setName("抽奖箱2");
        t1.start();
        t2.start();
        //获取多线程的运行结果
        Integer result = ft.get();
        System.out.println(result);

    }
}


package lx8;


import java.util.ArrayList;
import java.util.Collections;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;

public class Test {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
           /*
            有一个抽奖池,该抽奖池中存放了奖励的金额,该抽奖池中的奖项为 {10,5,20,50,100,200,500,800,2,80,300,700};
            创建两个抽奖箱(线程)设置线程名称分别为    "抽奖箱1", "抽奖箱2"
            随机从抽奖池中获取奖项元素并打印在控制台上,格式如下:
            在此次抽奖过程中，抽奖箱1总共产生了6个奖项，分别为：10,20,100,500,2,300
        	    最高奖项为300元，总计额为932元
            在此次抽奖过程中，抽奖箱2总共产生了6个奖项，分别为：5,50,200,800,80,700
            	最高奖项为800元，总计额为1835元

            在此次抽奖过程中,抽奖箱2中产生了最大奖项,该奖项金额为800元
            核心逻辑：获取线程抽奖的最大值（看成是线程运行的结果）

            以上打印效果只是数据模拟,实际代码运行的效果会有差异
        */
//创建抽奖箱奖池
        ArrayList<Integer> list = new ArrayList<>();
        Collections.addAll(list, 10, 5, 20, 50, 100, 200, 500, 800, 2, 80, 300, 700);

        /*
         1.定义一个类MyCallable实现Callable接口
        2.在MyCallable类中重写call()方法  有返回值的表示多线程运行的结果
        3.创建MyCallable类的对象 表示多线程要执行的任务
        4.创建Future的实现类FutureTask对象，把MyCallable对象作为构造方法的参数  作用：管理多线程运行的结果
        5.创建Thread类的对象，把FutureTask对象作为构造方法的参数 表示线程
        6.启动线程
        7.再调用get方法，就可以获取线程结束之后的结果。
         */

        //创建多线程要运行的参数对象
        Mycallable m = new Mycallable(list);
        //创建多线程运行结果的管理者对象
        FutureTask<Integer> ft1 = new FutureTask<>(m);
        FutureTask<Integer> ft2 = new FutureTask<>(m);
        //创建线程对象
        Thread t1 = new Thread(ft1);
        Thread t2 = new Thread(ft2);
        t1.setName("抽奖箱1");
        t2.setName("抽奖箱2");
        t1.start();
        t2.start();
        //获取多线程的运行结果
        Integer result1 = ft1.get();
        System.out.println(result1);
        Integer result2 = ft2.get();
        System.out.println(result2);
        //  在此次抽奖过程中,抽奖箱2中产生了最大奖项,该奖项金额为800元
        if (result1 > result2) {

            System.out.println("在此次抽奖过程中,抽奖箱1中产生了最大奖项,该奖项金额为800元");
        } else {

            System.out.println("在此次抽奖过程中,抽奖箱2中产生了最大奖项,该奖项金额为800元");
        }

    }
}

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/1959250.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

生成式：PolyGen: An Autoregressive Generative Model of 3D Meshes【附件】

生成式：PolyGen: An Autoregressive Generative Model of 3D Meshes【附件】

论文：PolyGen: An Autoregressive Generative Model of 3D Meshes OBJ坐标变换： # Transpose so that z-axis is vertical.vertices = vertices[:, [2, 0, 1]]变换前： 对应数据：
阅读更多...
springboot 微信消息推送 springboot sse推送

springboot 微信消息推送 springboot sse推送

目录 一、springboot 微信消息推送 springboot sse推送 1、在 Spring 框架中实现 2、传统的 Servlet 中实现 一、springboot 微信消息推送 springboot sse推送 关于 SSE SSE 全程 Server Send Event&#xff0c;是 HTTP 协议中的一种&#xff0c;Content-Type 为 text/event…
阅读更多...
MySQL存储引擎MyISAM和InnoDB

MySQL存储引擎MyISAM和InnoDB

1.1MySQL存储引擎 1.1.1概述 1、什么是存储引擎 MySQL中的数据用各种不同的技术存储在文件&#xff08;或内存&#xff09;中。这些技术中的每一种都使用不同的存储机制、索引技巧、锁定水平并且提供广泛的、不同的功能和能力&#xff1b;通过选择不同的技术&#xff0c;能够…
阅读更多...
JavaScript - 如何安装和配置Yarn包管理器

JavaScript - 如何安装和配置Yarn包管理器

作者&#xff1a;逍遥Sean 简介&#xff1a;一个主修Java的Web网站\游戏服务器后端开发者 主页&#xff1a;https://blog.csdn.net/Ureliable 觉得博主文章不错的话&#xff0c;可以三连支持一下~ 如有疑问和建议&#xff0c;请私信或评论留言&#xff01; 前言 Yarn是一个快速…
阅读更多...
Langchain--如何使用大模型 2.0

Langchain--如何使用大模型 2.0

【&#x1f34a;易编橙终身成长社群&#x1f34a;】 大家好&#xff0c;我是小森( &#xfe61;ˆoˆ&#xfe61; ) &#xff01; 易编橙终身成长社群创始团队嘉宾&#xff0c;橙似锦计划领衔成员、阿里云专家博主、腾讯云内容共创官、CSDN人工智能领域优质创作者 。 Langch…
阅读更多...
集合竞价逐笔数据验证,level2行情接口验证

集合竞价逐笔数据验证,level2行情接口验证

最近做集合竞价的策略&#xff0c;用的level2数据。集合竞价阶段推送数据量很大&#xff0c;但是不确定有没有因为网络原因的数据纰漏&#xff0c;所以需要验证一下。 把今天所有的数据记录了日志&#xff0c;其中筛选了09:25集合竞价的推送&#xff1a; grep 2024/07/29 09:2…
阅读更多...
Linux服务器安装Zabbix7.0客户端实战记录和问题记录

Linux服务器安装Zabbix7.0客户端实战记录和问题记录

1、获取最新的Zabbix客户端包&#xff0c;不同的linux的系统选择不同的安装包 阿里云镜像站 按照一下的格式惊醒编辑替换自己的安装包 openEuler&#xff1a;rpm -Uvh https://mirrors.aliyun.com/zabbix/zabbix/7.0/rhel/9/x86_64/zabbix-release-7.0-4.el9.noarch.rpm?sp…
阅读更多...
Python 实现股票指标计算——DKX

Python 实现股票指标计算——DKX

DKX - 多空线 1 公式 MID&#xff1a;(3*CLOSELOWOPENHIGH)/6&#xff1b; DKX&#xff1a;(20*MID)19*REF(MID&#xff0c;1)18*REF(MID&#xff0c;2)17*REF(MID&#xff0c;3) 16*REF(MID&#xff0c;4)15*REF(MID&#xff0c;5)14*REF(MID&#xff0c;6) 13*REF(MID&a…
阅读更多...
springboot高职院校毕业生信息管理系统-计算机毕业设计源码27889

springboot高职院校毕业生信息管理系统-计算机毕业设计源码27889

摘 要 基于Java语言开发的高职院校毕业生信息管理系统旨在提供一个便捷、高效的方式来管理毕业生的相关信息。系统包括学生基本信息管理、成绩管理、就业信息管理等模块&#xff0c;通过界面友好、操作简单的设计&#xff0c;方便管理员快速查询和更新学生信息。系统还提供数据…
阅读更多...
Vue2从基础到实战（指令修饰符）详解

Vue2从基础到实战（指令修饰符）详解

什么是指令修饰符&#xff1f; 指令修饰符就是通过“.”指明一些指令后缀 不同的后缀封装了不同的处理操作 —> 简化代码 按键修饰符 keyup.enter —>当点击enter键的时候才触发 v-model修饰符 v-model.trim —>去除首位空格 v-model.number —>转数字 事件修…
阅读更多...
使用docker在CentOS 7上安装php+mysql+nginx环境教程并运行WordPress

使用docker在CentOS 7上安装php+mysql+nginx环境教程并运行WordPress

文章目录 一、安装docker1、切换yum源并更新系统2、卸载旧版docker3、配置Docker的yum库4、安装Docker5、启动和校验Docker6、配置镜像加速6.1、注册阿里云账号6.2、开通镜像服务6.3、配置镜像加速二、部署php+mysql+nginx环境1、准备目录结构2、拉取镜像3、运行容器并从中拷贝…
阅读更多...
【Opencv】模糊

【Opencv】模糊

消除噪声 用该像素周围的平均值代替该像素值 4个函数 blur():最经典的 import os import cv2 img cv2.imread(os.path.join(.,dog.jpg)) k_size 7 #窗口大小&#xff0c;数字越大&#xff0c;模糊越强 img_blur cv2.blur(img,(k_size,k_size)) #窗口是正方形&#xff…
阅读更多...
用依赖倒置和控制反转，突破Golang循环调用限制之后的思考

用依赖倒置和控制反转，突破Golang循环调用限制之后的思考

在软件开发中&#xff0c;随着项目规模的扩大和业务逻辑的复杂化&#xff0c;重构代码变得越来越重要。本文将介绍如何在既有代码基础上&#xff0c;通过依赖倒置&#xff08;DIP&#xff09;和控制反转&#xff08;IoC&#xff09;&#xff0c;实现新增加的代码可以循环引用到…
阅读更多...
UI设计经验心得：优化设计流程与实战技巧分享

UI设计经验心得：优化设计流程与实战技巧分享

随着互联网的快速发展&#xff0c;UI 设计在中国也逐渐发展起来。UI 设计的目的不仅仅是让用户享受视觉享受&#xff0c;而是解决用户如何与互联网设备互动。因此&#xff0c;UI 设计是通过深入研究用户的使用习惯和操作逻辑来设计界面的互动和视觉效果。那么&#xff0c;UI 设…
阅读更多...
邮箱API在CRM系统中如何高效的应用与集成？

邮箱API在CRM系统中如何高效的应用与集成？

邮箱API的高级功能和使用指南&#xff1f;怎么安全集成邮箱API&#xff1f; CRM系统已成为企业与客户保持联系的关键工具。通过集成邮箱API&#xff0c;企业可以大幅提升CRM系统的功能和效率。AokSend将探讨邮箱API在CRM系统中的高效应用与集成。 邮箱API&#xff1a;主要功能…
阅读更多...
龙迅LT8642UXE 矩阵HDMI *4转HDMI *2输出切换芯片，支持HDMI 2.0，可带HDCP

龙迅LT8642UXE 矩阵HDMI *4转HDMI *2输出切换芯片，支持HDMI 2.0，可带HDCP

LT8642UXE描述&#xff1a; LT8642UXE HDMI2.0/1.4交换机具有4&#xff1a;2的开关&#xff0c;符合HDMI2.0/1.4规格&#xff0c;最大6Gbps高速数据速率&#xff0c;自适应均衡RX输入和预先强调的TX输出&#xff0c;以支持长电缆应用程序。LT8642UXE HDMI2.0/1.4交换机自动检测…
阅读更多...
JVM—运行时数据区域

JVM—运行时数据区域

Java 虚拟机在执行 Java 程序的过程中会把它所管理的内存划分为若干个不同的数据区域。 1、程序计数器—线程私有 字节码解释器工作时通过改变这个计数器的值&#xff0c;选取下一条执行的字节码指令。程序计数器是程序控制的指示器&#xff0c;分支、循环、跳转、异常处理、线…
阅读更多...
适合证券公司的跨网传输解决方案，了解一下

适合证券公司的跨网传输解决方案，了解一下

证券公司由于其业务特性&#xff0c;涉及大量的敏感财务数据和交易信息&#xff0c;因此通常会在内部实施网络隔离措施。目的是为了保护数据免受未授权访问和网络攻击&#xff0c;确保数据的安全性和保密性&#xff0c;因此急需寻找安全可靠的跨网传输解决方案&#xff0c;实现…
阅读更多...
拆解了数百个独立站，我们总结的高转化页面布局精华

拆解了数百个独立站，我们总结的高转化页面布局精华

高转化的独立站的页面布局都具备什么要素呢&#xff1f; 我们研究了几百个独立站&#xff0c;结合我们自己的项目经验&#xff0c;总结出转化率相对高的网站布局&#xff0c;都有以下注意的要点清单&#xff1a; 1 品牌Logo基本放在头部左边或者中间 2 首屏大banner 3 社交媒…
阅读更多...
【可能是全网最丝滑的LangChain教程】十九、LangChain进阶之Agents

【可能是全网最丝滑的LangChain教程】十九、LangChain进阶之Agents

幸福&#xff0c;不是长生不老&#xff0c;不是大鱼大肉&#xff0c;不是权倾朝野。幸福是每一个微小的生活愿望达成。当你想吃的时候有得吃&#xff0c;想被爱的时候有人来爱你。 01 Agent介绍 在LangChain中&#xff0c;Agent 是一个核心概念&#xff0c;它代表了一种能够利…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023