简单了解java中线程的使用

最新推荐文章于 2024-09-03 20:17:53 发布
最新推荐文章于 2024-09-03 20:17:53 发布
阅读量913 收藏 26
点赞数 36
分类专栏： java-study 文章标签： java 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_63323754/article/details/139622841
版权

线程

1、线程的相关概念

1.1、并行和并发

并行：在同一时刻，有多个任务在多个CPU上同时执行

并发：在同一时刻，有多个任务在单个CPU上交替执行

1.2、进程和线程

进程：就是在多任务管理系统中，每个独立执行的程序，进程就是”正在进行的程序“

线程：就是程序运行的基本单元。当操作系统执行一个程序时，会在系统中建立一个进程，该进程必须至少建立一个线程（这个线程被称为主线程）作为这个程序运行的入口点。因此，在操作系统中运行的任何程序都至少有一个线程。

2、什么是多线程？

是指从软件或者硬件上实现多个线程并发执行的技术。

具有多线程能力的计算机因为硬件支持而能够在同一时间执行多个线程，提升性能。

3、线程的使用

3.1、使用多线程的好处

提高程序的效率

3.2、多线程如何开发

3.2.1、线程启动方式之Thread类（java语言提供的线程类）

概述：java.lang.Thread是线程类，可以用来给进程创建线程处理任务使用，其中线程中有两个中要的方法：

  • public void run()：线程执行任务的方法，是线程启动后第一个执行的方法
  • public void start()：启动线程的方法，线程对象调用该方法后，Java虚拟机就会调用此线程的run方法

线程启动步骤：

  • 创建一个子类继承Thread类（创建的子类也是线程类）
  • 在子类中，编写让线程完成的任务（任务代码）
  • 重写Thread类中的run方法（线程任务）
  • 启动线程

示例：

创建一个子类线程：

public class MyThread extends Thread{
    @Override
    public void run() {
        System.out.println("我的线程开始啦");
        for (int i = 100; i < 200; i++) {
            System.out.println("我的线程：" + i);
        }
    }
}

在main中启动子线程

public class ThreadDemo1 {
    public static void main(String[] args) {
        //创建一个线程对象
        MyThread myThread = new MyThread();

        //启动线程
        myThread.start();

        //主线程代码
        for (int i = 0; i < 100; i++) {
            System.out.println("主线程：" + i);
        }
    }
}

结果展示（展示部分）：

主线程：0
我的线程开始啦
主线程：1
我的线程：100
我的线程：101
我的线程：102
主线程：2
我的线程：103
主线程：3
我的线程：104
我的线程：105
我的线程：106
主线程：4
主线程：5
我的线程：107
主线程：6
我的线程：108
主线程：7
主线程：8
主线程：9
主线程：10
主线程：11
主线程：12
主线程：13
主线程：14
我的线程：109
主线程：15
我的线程：110
我的线程：111
我的线程：112
我的线程：113
我的线程：114
我的线程：115
主线程：25
...
3.2.2、线程启动方式之Runnable接口（推荐使用，灵活度高，因为允许子类继承其他父类）

使用的构造方法：

  • public Thread(Runnable target)

  • public Thread(Runnable target, String name)

参数中的Runnable是一个接口，用来定义线程要执行的任务

线程启动步骤：

  • 定义任务类实现Runnable，并重写run方法
  • 创建任务对象
  • 使用含有Runnable参数的构造方法，创建线程对象并指定任务
  • 调用线程start方法，开启线程

示例：

任务类

public class MyTask implements Runnable{
    @Override
    public void run() {
        for (int i = 100; i < 200; i++) {
            System.out.println("新线程："+ i);
        }
    }
}

启动线程

public class ThreadDemo1 {
    public static void main(String[] args) {
        MyTask myTask = new MyTask();

        Thread t = new Thread(myTask);

        t.start();

        for (int i = 0; i < 100; i++) {
            System.out.println("主线程：" + i);
        }
    }
}

运行结果与上面相似

4、线程中的常用方法

方法说明
String getName()获取线程名字
viod setName()给线程设置一个名字
public static Thread currentThread()返回当前正在执行的线程对象的引用
public static void sleep(long time)让线程休眠指定的时间，单位为毫秒
public void join()具备阻塞作用，等待这个线程死亡，才会执行其他线程

获取线程名字示例：

public class ThreadTask implements Runnable{
    @Override
    public void run() {
        for (int i = 0; i < 30; i++) {
            //获取                     当前线程          的名字
            System.out.println(Thread.currentThread().getName() + ": " + i);
        }
    }
}


public class Test1 {
    public static void main(String[] args) {
        new Thread(new ThreadTask()).start();

        for (int i = 100; i <120 ; i++) {
            System.out.println(Thread.currentThread().getName() + ": " + i);
        }
    }
}

运行结果（部分展示）：

main: 100
Thread-0: 0
main: 101
Thread-0: 1
main: 102
Thread-0: 2
main: 103
Thread-0: 3
main: 104
Thread-0: 4
main: 105

其他方法，大家可以自行尝试。

5、线程的安全问题

5.1、发生安全问题的原因

多个线程对同一个数据，进行读写操作，造成数据错乱

案例分析：我们现在设计一个卖票程序，票数总共100张，设置三个售票处

思路：

  • 定义一个类Ticket实现Runnable接口，里面定义一个成员变量Private int count = 100
  • 在Ticket类中重写run()方法实现卖票，代码如下

Ticket类

public class Ticket implements Runnable{
    private int count = 100;

    @Override
    public void run() {
        while (true){
            if(count > 0){

                //模拟出票时间延迟
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }

                System.out.println(Thread.currentThread().getName() + "票号：" + count);
                count--;
            }
            if(count == 0){
                break;
            }
        }
    }
}

Test类

public class Test {
    public static void main(String[] args) {
        Ticket ticket = new Ticket();

        //三个售票处
        Thread t1 = new Thread(ticket, "售票处1-");
        Thread t2 = new Thread(ticket, "售票处2-");
        Thread t3 = new Thread(ticket, "售票处3-");

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

当我们运行后，发现结果出现了问题，有些情况不在我们的预期之中，不符合常理

比如出现了重复票：

售票异常1

还有出现了0号票：

售票异常2

为什么会出现这些奇怪的问题呢？很简单，这是因为多线程操作共享数据。解决这些问题的基本思路就是让共享数据存在安全环境中，当某一个线程访问共享数据时，其他线程是无法操作的。

具体实现：

  • 把多条线程操作共享数据的代码给锁起来，让任意时刻只能有一个线程执行即可
  • java提供了同步代码块的实现方式来解决

5.2、同步代码块

5.2.1、线程同步

java允许多线程并发执行，当多个线程同时操作一个可共享的资源变量时（比如数据的增删改查），将会导致数据不准确，相互之间产生冲突，因此加入同步锁，以避免在该线程没有完成操作之前，被其它线程调用，从而保证该变量的唯一性和准确性。

5.2.2、同步代码块

锁住多条语句操作共享数据，可以使用同步代码块实现

  • 格式：
synchronized(任意对象){
    多条件语句操作共享数据的代码
}
  • 默认情况锁是打开的，只要有一个线程进去执行代码了，锁就会关闭
  • 当线程执行完成出来后，锁才会自动打开
  • 锁对象是任意对象，但是多个线程必须使用同一把锁

同步的好处和弊端：

  • 好处：解决了多线程的数据安全问题
  • 弊端：当线程很多时，因为每个线程都会去判断同步上的锁，这是很耗费资源的，无形中会降低程序的运行效率

所以上面Ticket类中可以修改为：

public class Ticket implements Runnable{
    private int count = 100;

    Object lock = new Object();

    @Override
    public void run() {
        while (true){
            synchronized (lock){//锁对象可以时任意对象
                if(count > 0){

                    //模拟出票时间延迟
                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        throw new RuntimeException(e);
                    }

                    System.out.println(Thread.currentThread().getName() + "票号：" + count);
                    count--;
                }
                if(count <= 0){
                    break;
                }
            }
        }
    }
}
5.2.3、同步方法

**概念：**就是把synchronized关键字加到方法上，保证线程执行该方法的时候，其他线程只能在方法外等着

  • 格式
修饰符 synchronized 返回值类型 方法名(方法参数){

}

  • 同步代码块和同步方法的区别

    同步代码块可以锁住指定代码，同步方法是锁住方法中的所有代码

    同步代码块可以指定锁对象，同步方法不能指定锁对象

虽然同步方法不能指定锁对象，但是有默认存在的锁对象

对于非static方法，同步锁就是this

对于static方法，我们使用当前方法所在类的字节码对象（类名.class）。Class类型的对象

public class Ticket implements Runnable{
    private int count = 100;

    @Override
    public void run() {
        while (true){
            if(count <= 0){
                break;
            }

            demo();
        }
    }

    private synchronized void demo(){
        if(count > 0){

            //模拟出票时间延迟
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }

            System.out.println(Thread.currentThread().getName() + "票号：" + count);
            count--;
        }
    }
}

6、Lock锁机制

虽然我们可以理解同步代码块和同步方法的锁对象问题，但是我们并没有直接看到在哪里加上了锁，在哪里释放了它，为了更清晰的表达如何加锁和释放锁，JDK5以后提供了一个新的锁对象Lock。

Lock中提供了获得锁和释放锁的方法

  • void lock()：获得锁
  • void unlock()：释放锁

Lock是接口不能实例化，这里采用它的实现类ReentrantLock来实例化，ReentrantLock的构造方法是：ReentrantLock()。

注意：多个线程使用相同的Lock锁对象，需要多线程操作数据的代码放在lock()和unlock()方法之间。一定要确保最后unlock能够调用。

上述Ticket类可以修改为这样：

public class Ticket implements Runnable{
    private int count = 100;

    //获取锁对象
    Lock lock = new ReentrantLock();

    @Override
    public void run() {
        while (true){
            //上锁
            lock.lock();
            if(count <= 0){
                break;
            }

            if(count > 0){

                //模拟出票时间延迟
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }

                System.out.println(Thread.currentThread().getName() + "票号：" + count);
                count--;
            }
            //释放锁
            lock.unlock();
        }
    }
}

7、线程通讯

7.1、概念

在多线程程序中，某个线程进入到等待状态时，必须有其他线程来唤醒处于等待状态的线程。

7.2、线程通讯需要使用的API

7.2.1、等待方法
  • wait()：无线等待（只能由其他线程唤醒）
  • wait(long 毫秒)：计时等待，时间到了自动唤醒

以上两个方法调用会导致当前线程释放掉锁资源

7.2.3、唤醒方法
  • notify()：唤醒处于等待状态的任意个线程
  • notityAll()：唤醒处于等待状态的所有线程

以上两个方法调用不会导致当前线程释放掉锁资源

无限等待唤醒示例：

public class Test {
    public static void main(String[] args) {
        Runnable task = new Runnable() {
            Object lock = new Object();
            boolean flag = true;

            @Override
            public void run() {
                synchronized (lock){
                    if(flag){
                        flag = false;
                        System.out.println("线程进入无限等待...");
                        try {
                            lock.wait();
                            System.out.println("程序继续执行啦~");
                        } catch (InterruptedException e) {
                            throw new RuntimeException(e);
                        }
                    }else{
                        System.out.println("线程即将被唤醒");
                        try {
                            Thread.sleep(2000);
                        } catch (InterruptedException e) {
                            throw new RuntimeException(e);
                        }
                        lock.notify();
                    }
                }
            }
        };

        new Thread(task).start();
        new Thread(task).start();
    }
}

计时等待唤醒示例：

public class Test01 {
    public static void main(String[] args) {
        new Thread(() -> {
            Object lock = new Object();

           synchronized (lock){
               try {
                   System.out.println("即将进入计时等待...");
                   lock.wait(2000);
                   System.out.println("两秒了，程序继续执行");
               } catch (InterruptedException e) {
                   throw new RuntimeException(e);
               }
           }
        }).start();
    }
}

总结：

  • 等待和唤醒方法调用需要使用对象锁，需要在同步代码中完成
  • wait()进入无限等待，wait(时间)进入计时等待
  • 唤醒线程的方法是notify【唤醒处于和notify使用同一对象锁上的，处于等待状态的任意线程】、notifyAll【同notify】

最后给大家来一个经典的生产者消费者简单线程代码示例：

公共资源类

public class Food {
    //判断是否有食物
    public static boolean food = true;

    //锁
    public static final Object lock = new Object();
}

生产者

public class Producer implements Runnable{
    @Override
    public void run() {
        synchronized (Food.lock){
            while(true){
                //判断是否有食物，有食物则进行等待，反之则生产食物
                if(Food.food){
                    //将食物标识设置为无
                    //Food.food = false;

                    System.out.println(Thread.currentThread().getName() + "此时进行等待消费者消费~");

                    try {
                        Food.lock.wait();
                    } catch (InterruptedException e) {
                        throw new RuntimeException(e);
                    }
                }else{
                    System.out.println(Thread.currentThread().getName() + "发现没有食物，开始生产~");

                    //制作食物的时间
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        throw new RuntimeException(e);
                    }
                    Food.food = true;

                    //唤醒消费者
                    Food.lock.notify();
                }
            }
        }
    }

    public Producer() {
    }
}

消费者

public class Consumer implements Runnable{
    @Override
    public void run() {
        //判断是否有食物，有则消费，没有则等待
        synchronized (Food.lock){
            while(true){
                if(Food.food){
                    System.out.println(Thread.currentThread().getName() + "发现食物，开炫~");

                    //消费时长
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        throw new RuntimeException(e);
                    }
                    Food.food = false;

                    //唤醒生产者继续生产
                    Food.lock.notify();
                }else{
                    System.out.println(Thread.currentThread().getName() + "没有发现食物，叫厨师~");

                    try {
                        Food.lock.wait();
                    } catch (InterruptedException e) {
                        throw new RuntimeException(e);
                    }
                }
            }
        }
    }

    public Consumer() {
    }
}

测试类

public class Test {
    public static void main(String[] args) {
        new Thread(new Producer(), "生产者").start();
        new Thread(new Consumer(), "消费者").start();
    }
}

部分运行结果

生产者此时进行等待消费者消费~
消费者发现食物，开炫~
消费者没有发现食物，叫厨师~
生产者发现没有食物，开始生产~
生产者此时进行等待消费者消费~
消费者发现食物，开炫~
消费者没有发现食物，叫厨师~
......

8、线程池

8.1、概述

8.1.1、线程使用存在的问题

如果并发的线程数量很多，并且每个线程都是执行一个很短的任务就结束了，这样频繁的创建线程就会大大降低系统的效率，因为频繁创建线程和销毁线程需要时间。

如果大量线程在执行，会涉及到线程间上下文的切换，会极大的消耗CPU运算资源

8.1.2、线程池认识

其实就是一个容纳多个线程的容器，其中的线程可以反复使用，省去了频繁创建线程对象的操作，无需反复创建线程而消耗过多资源

8.1.3、线程池使用的大致流程
  • 创建线程池，指定线程开启数量
  • 提交任务给线程池，线程池中的线程就会获取任务，进行任务处理
  • 线程处理完任务不会销毁，而是返回到线程池中，等待下一个任务执行
  • 如果线程池中所有的线程都被占用，提交任务，只能等待线程池中的线程处理完当前任务
8.1.4、线程池的好处
  • 降低资源消耗：减少了创建和销毁线程的次数，每个工作线程都可以被重复利用，可以执行多个任务。
  • 提高响应速度：当任务到达时，任务可以不需要等待线程创建，就能立即执行
  • 提高线程的可管理性：可以根据系统的承受能力，调整线程池中工作线线程池的数目，防止因为消耗过多内存，服务器死机。

8.2、线程池中的API

8.2.1、线程池API学习

java.util.concurrent.ExecutorService是线程池接口类型，使用时我们不需要自己实现，JDK已经帮我们实现好了。获取线程池我们使用工具类java.util.concurrent.Executor的静态方法。

public static ExecutorService newFixedThreadPool(int num)指定线程池最大线程池数量获取线程池

线程池ExcutorService的相关方法：

提交执行的任务方法：

< T>Future< T>submit(Callable< T> task)

Future< ?> submit(Runnable task)

关闭线程池方法：

void shutdown() 启动一次顺序关闭，执行以前提交任务，但不接受新任务

示例：有三个老师要对五个学生进行一对一辅导：

public class Pool implements Runnable{
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName() + "在辅导学生学习");
    }
}

public class Test {
    public static void main(String[] args) {
        ExecutorService pool = Executors.newFixedThreadPool(3);

        pool.submit(new Pool());
        pool.submit(new Pool());
        pool.submit(new Pool());
        pool.submit(new Pool());
        pool.submit(new Pool());
    }
}

测试结果：

pool-1-thread-2在辅导学生学习
pool-1-thread-1在辅导学生学习
pool-1-thread-3在辅导学生学习
pool-1-thread-1在辅导学生学习
pool-1-thread-2在辅导学生学习

8.3、Callable接口

8.3.1、概述
public interface Callable<V> {
	V call() throws Exception;
}

Callable和Runnable的不同点：

  • Callable支持返回结果，Runnable不行
  • Callable支持抛出异常，Runnable不行
8.3.2、使用步骤
  • 创建线程池
  • 定义Callable任务
  • 创建Callable任务，提交任务给线程池
  • 获取执行结果

利用线程池计算0-n的和并返回结果：

public class CallableDemo {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        ExecutorService demo = Executors.newFixedThreadPool(10);

        Callable<Integer> task = new Callable<Integer>() {
            @Override
            public Integer call() throws Exception {
                int sum = 0;
                for (int i = 1; i <= 10; i++) {
                    sum += i;
                }
                return sum;
            }
        };

        Future<Integer> future = demo.submit(task);
        System.out.println(future.get());
    }
}

ble和Runnable的不同点：**

  • Callable支持返回结果，Runnable不行
  • Callable支持抛出异常，Runnable不行
8.3.2、使用步骤
  • 创建线程池
  • 定义Callable任务
  • 创建Callable任务，提交任务给线程池
  • 获取执行结果

利用线程池计算0-n的和并返回结果：~

public class CallableDemo {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        ExecutorService demo = Executors.newFixedThreadPool(10);

        Callable<Integer> task = new Callable<Integer>() {
            @Override
            public Integer call() throws Exception {
                int sum = 0;
                for (int i = 1; i <= 10; i++) {
                    sum += i;
                }
                return sum;
            }
        };

        Future<Integer> future = demo.submit(task);
        System.out.println(future.get());
    }
}

呼~~~

T糖锅G
关注
  • 36
    点赞
  • 踩
  • 26
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
简单了解Java编程中线程的创建与守护线程
09-03
Java编程中的线程创建是多线程并发编程的核心部分，它允许程序同时执行多个任务，从而提高效率和响应速度。线程有两种主要的创建方式：通过实现`Runnable`接口和通过继承`Thread`类。这两种方式各有优劣，适用于不同...
简单了解Java多线程实现的四种方式
08-19
这种方式的优点是简单易懂，缺点是因为 Java 的单继承多实现特性，不建议使用这种方式。示例代码如下： ```java public class Demo extends Thread { public static void main(String[] args) { new Demo().start...
Java 线程的使用
weixin_53472653的博客
06-02 3350
尚硅谷学习笔记
【java多线程】线程常用操作方法总结
taojin12的博客
01-02 916
文章目录线程的命名与获取线程休眠线程中断线程强制运行线程礼让线程优先级 多线程的主要操作方法都在Thread类中定义了。 线程的命名与获取 &amp;nbsp;&amp;nbsp;&amp;nbsp;&amp;nbsp;&amp;nbsp;&amp;nbsp;多线的的运行状态是不确定的，那么在程序的开发之中为了可以获取一些需要使用线程就只能够依靠线程的名字来进行操作。所以线程的名字是一个至关重要的概念，这样在Thread类之中就提供有线程名称的...
java 线程 (一) 线程的简单使用
llk15884975173的博客
10-24 1万+
大家好，从今天开始，我和大家一起来探讨 java 中线程的使用。线程是 java 知识体系中非常重要的一部分，我将写一系列的文章来详细的介绍 java 线程中需要掌握的知识。如果你是 java 线程的初学者，本系列文章你一定不要错过哦。 本篇文章是 java 线程系列文章的第一篇文章，主要介绍进程与线程的概念和 java 中如何使用线程。 1 进程与线程 1.1 进程的概念 首先我们先来介绍一下什么是进程。 进程可以理解为一个个正在执行的应用程序，比如我们使用网易云音乐软件播放音乐，同时我们在使用 WP
Java多线程（超详细！）
一只小菜鸡
05-13 12万+
1、什么是进程？什么是线程？ 进程是:一个应用程序（1个进程是一个软件）。 线程是：一个进程中的执行场景/执行单元。 注意：一个进程可以启动多个线程。 eg.对于java程序来说，当在DOS命令窗口中输入： java HelloWorld 回车之后。 会先启动JVM，而JVM就是一个进程。 JVM再启动一个主线程调用main方法。 同时再启动一个垃圾回收线程负责看护，回收垃圾。 最起码，现在的java程序中至少有两个线程并发， 一个是垃圾回收线程，一个是执行main方法的主线程。 3、进程和线程是什么关系？
java多线程
m0_46702681的博客
06-19 2106
javajava。
Java多线程实战-实现多线程文件下载，支持断点续传、日志记录等功能
qq_35716689的博客
03-10 23万+
本文将介绍如何通过Java来实现一个多线程下载器。作者：牵着猫散步的鼠鼠
编程必备：JAVA多线程详解
拾一二的博客
06-14 8511
多线程已经成为一种常见的编程模式，广泛应用于各种不同类型的应用程序中。本篇博客文章中，我们将会探讨多线程编程的相关知识和技巧。通过代码示例和实际应用案例来深入了解多线程的具体实现和应用方法，帮助更好地掌握多线程编程技术，提高程序效率和性能。后期随学习深入还会补充修改。以上就是我对多线程的个人简介，后续会不断完善更新，与大家共勉。
Java多线程学习（吐血超详细总结）
热门推荐
Evankaka的专栏
03-14 41万+
本文主要讲了java中多线程的使用方法、线程同步、线程数据传递、线程状态及相应的一些线程函数用法、概述等。
Java多线程实战-从零手搓一个简易线程池(一)定义任务等待队列
qq_35716689的博客
03-25 22万+
开个新坑-手搓简易线程池。本系列文章将从零开始,一步步手工编码实现一个简单但功能完备的线程池。我们将逐步介绍线程池的各个核心组件,并分析它们的作用和实现思路。通过这个过程,我们可以更好地掌握多线程编程的技巧,并培养编码能力和系统性思维。
简单了解Java创建线程两种方法
08-25
Java语言中提供了两种创建线程的方法，一种是通过继承Thread类，另一种是通过实现Runnable接口。在本篇文章中，我们将通过示例代码详细介绍这两种方法的实现过程。 1. 通过继承Thread类创建线程 在Java语言中，...
简单了解Java Netty Reactor三种线程模型
08-19
Reactor 模式是指在网络编程中，使用单个线程或多个线程来处理所有的IO操作。下面我们将详细介绍 Java Netty Reactor 的三种线程模型。 1. 单线程模型 单线程模型是指所有的IO操作都在同一个NIO线程上面完成。NIO...
浅析synchronized锁升级的原理与实现 1
水w的博客
09-01 1182
浅析synchronized锁升级的原理与实现
SpringBoot 项目集成 xxl-job
qq_58159506的博客
09-03 558
SpringBoot 项目集成 xxl-job
nmt---Docker-compose自动化部署
qq_69920145的博客
09-03 697
static-rr 权重, leastconn 最少连接, source 请求IP, 轮询 roundrobin。# 这⾥是容器中的IP地址，由于配置的是轮询roundrobin，weight 权重其实没有⽣效。# 这⾥是容器中的IP地址，由于配置的是轮询roundrobin，weight 权重其实没有⽣效。# 在 mysql 创建⼀个没有权限的haproxy⽤户，密码为空。# 在 mysql 创建⼀个没有权限的haproxy⽤户，密码为空。10. docker-compose移除容器。
在Java Web开发中，如何保障应用的安全性？请列举常见的安全策略和措施。请解释Spring框架中的事务管理，包括声明式事务和编程式事务。
最新发布
weixin_53180424的博客
09-03 669
在实际开发中，声明式事务管理因其非侵入性和易维护性而更受欢迎。它允许开发者将注意力集中在业务逻辑上，而不是事务管理的细节上。然而，在某些特殊场景下，编程式事务管理可能提供更灵活的控制力。因此，在选择事务管理方式时，应根据实际需求和场景来决定。
计算机毕业设计选题推荐-任务管理系统-项目任务分配系统-Java/Python项目实战
IT研究室的博客
09-03 556
随着信息化技术的迅猛发展，各类企业和组织越来越依赖于高效的任务管理系统以保证其日常运营的顺利进行。根据IDC（国际数据公司）发布的报告显示，全球企业在数字化转型上的投入已达数千亿美元，其中相当一部分资金用于提升企业内部的管理效率。任务管理系统作为企业信息化的重要组成部分，能有效帮助企业分配、监控和反馈任务，从而提高工作效率。然而，尽管市场上已有多种任务管理系统，它们在功能、用户体验和适用性上存在显著差异。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值