Java中创建线程的方式

于 2024-07-13 20:10:26 发布
阅读量810 收藏 16
点赞数 15
分类专栏： 编程随笔 Java并发编程 文章标签： 创建线程方式 线程池 Thread Runnable Callable
版权声明：本文为博主原创文章，遵循 CC 4.0 BY 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/white_pure/article/details/140405456
版权

文章目录

创建线程

在Java中创建一个线程，有且仅有一种方式，创建一个Thread类实例，并调用它的start方法。

Thread

最经典也是最常见的方式是通过继承Thread类，重写run()方法来创建线程。适用于需要直接控制线程生命周期的情况。

public class MainTest {
    public static void main(String[] args) {
        ThreadDemo thread1 = new ThreadDemo();
        thread1.start();
    }
}
class ThreadDemo extends Thread {
    @Override
    public void run() {
        System.out.printf("通过继承Thread类的方式创建线程,线程 %s 启动",Thread.currentThread().getName());
    }
}

Runnable

实现Runnale接口，将它作为target参数传递给Thread类构造函数的方式创建线程。

public class MainTest {
    public static void main(String[] args) {
        new Thread(() -> {
            System.out.printf("通过实现Runnable接口的方式，重写run方法创建线程；线程 %s 启动",Thread.currentThread().getName());
        }).start();
    }
}

Callable

Callable接口与Runnable类似，但它可以返回结果，并且可以抛出异常，需要配合Future接口使用。通过实现Callable接口，来创建一个带有返回值的线程。在Callable执行完之前的这段时间，主线程可以先去做一些其他的事情，事情都做完之后，再获取Callable的返回结果。可以通过isDone()来判断子线程是否执行完。

public class MainTest {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        FutureTask<String> futureTask = new FutureTask<>(() -> {
            System.out.printf("通过实现Callable接口的方式，重写call方法创建线程；线程 %s 启动", Thread.currentThread().getName());
            System.out.println();
            Thread.sleep(10000);
            return "我是call方法返回值";
        });
        new Thread(futureTask).start();

        System.out.println("主线程工作中 ...");
        String callRet = null;
        while (callRet == null){
            if(futureTask.isDone()){
                callRet = futureTask.get();
            }
            System.out.println("主线程继续工作 ...");
        }
        System.out.println("获取call方法返回值："+ callRet);
    }
}

在实际开发中，通常使用异步编程工具，如CompletableFuture。CompletableFuture是JDK8的新特性。CompletableFuture实现了CompletionStage接口和Future接口，前者是对后者的一个扩展，增加了异步会点、流式处理、多个Future组合处理的能力，使Java在处理多任务的协同工作时更加顺畅便利。

public class CompletableFutureRunAsyncExample {
    public static void main(String[] args) {
        CompletableFuture<Void> future = CompletableFuture.runAsync(() -> {
            // 异步执行的任务，没有返回值
            System.out.println("Running asynchronously");
        });

        future.thenRun(() -> {
            System.out.println("After running asynchronously");
        });

        future.join(); // 等待任务完成

        CompletableFuture<String> future = CompletableFuture.supplyAsync(() -> "Hello")
                .thenApply(result -> result + " CompletableFuture!");
    }
}

线程池

线程池做的工作主要是控制运行的线程的数量，处理过程中将任务放入队列，然后在线程创建后启动这些任务。如果线程数量超过了最大数量超出数量的线程排队等候，等其它线程执行完毕，再从队列中取出任务来执行。线程池是一种用于管理和复用线程的机制，可以有效地提高应用程序的性能和资源利用率。它的主要特点为：线程复用，提高响应速度，管理线程。

  • 降低资源消耗，通过重复利用己创建的线程降低线程创建和销毁造成的消耗。
  • 提高响应速度，当任务到达时，任务可以不需要的等到线程创建就能立即执行。
  • 提高线程的管理性，线程是稀缺资源，如果无限制的创建，不仅会消耗系统资源，还会降低系统的稳定性，使用线程池可以进行统一的分配，调优和监控。
创建方式

在Java中，使用java.util.concurrent包中的Executor来创建和管理线程池。几种常见的线程池创建方式：

  • Executors.newSingleThreadExecutor()：创建只有一个线程的线程池。
  • Executors.newFixedThreadPool(int)：创建固定线程的线程池。
  • Executors.newCachedThreadPool()：创建一个可缓存的线程池，线程数量随着处理业务数量变化。

这三种常用创建线程池的方式，底层代码都是用ThreadPoolExecutor创建的。

  1. 使用Executors.newSingleThreadExecutor()创建一个单线程化的线程池，它只会用唯一的工作线程来执行任务，保证所有任务按照指定顺序执行。newSingleThreadExecutor将corePoolSize和maximumPoolSize都设置为1，它使用的LinkedBlockingQueue。

    public static ExecutorService newSingleThreadExecutor() {
    return new FinalizableDelegatedExecutorService
        (new ThreadPoolExecutor(1, 1,
                                0L, TimeUnit.MILLISECONDS,
                                new LinkedBlockingQueue<Runnable>()));
}

    public class MainTest {
    public static void main(String[] args) {
        ExecutorService executor1 = null;
        try {
            executor1 = Executors.newSingleThreadExecutor();
            for (int i = 1; i <= 10; i++) {
                executor1.execute(() -> {
                    System.out.println(Thread.currentThread().getName() + "执行了");
                });
            }
        } finally {
            executor1.shutdown();
        }
    }
}

  2. 使用Executors.newFixedThreadPool(int)创建一个定长线程池，可控制线程最大并发数，超出的线程会在队列中等待。newFixedThreadPool创建的线程池corePoolSize和maximumPoolSize值是相等的，它使用的LinkedBlockingQueue。

    public static ExecutorService newFixedThreadPool(int nThreads) {
    return new ThreadPoolExecutor(nThreads, nThreads,
                                  0L, TimeUnit.MILLISECONDS,
                                  new LinkedBlockingQueue<Runnable>());
}

    public class MainTest {
    public static void main(String[] args) {
        ExecutorService executor1 = null;
        try {
            executor1 = Executors.newFixedThreadPool(10);
            for (int i = 1; i <= 10; i++) {
                executor1.execute(() -> {
                    System.out.println(Thread.currentThread().getName() + "执行了");
                });
            }
        } finally {
            executor1.shutdown();
        }
    }
}

  3. 使用Executors.newCachedThreadPool()创建一个可缓存线程池，如果线程池长度超过处理需要，可灵活回收空闲线程，若无可回收则新建线程。newCachedThreadPool将corePoolSize设置为0，将maximumPoolSize设置为Integer.MAX_VALUE，使用的 SynchronousQueue，也就是说来了任务就创建线程运行，当线程空闲超过60秒，就销毁线程。

    public static ExecutorService newCachedThreadPool() {
    return new ThreadPoolExecutor(0, Integer.MAX_VALUE,
                                  60L, TimeUnit.SECONDS,
                                  new SynchronousQueue<Runnable>());
}

    public class MainTest {
    public static void main(String[] args) {
        ExecutorService executor1 = null;
        try {
            executor1 = Executors.newCachedThreadPool();
            for (int i = 1; i <= 10; i++) {
                executor1.execute(() -> {
                    System.out.println(Thread.currentThread().getName() + "执行了");
                });
            }
        } finally {
            executor1.shutdown();
        }
    }
}
自定义线程池

在实际开发中用哪个线程池？上面的三种一个都不用，我们生产上只能使用自定义的。Executors类中已经给你提供了，为什么不用？

摘自《阿里巴巴开发手册》
【强制】线程资源必须通过线程池提供，不允许在应用中自行显式创建线程。
说明：线程池的好处是减少在创建和销毁线程上所消耗的时间以及系统资源的开销，解决资源不足的问题。 如果不使用线程池，有可能造成系统创建大量同类线程而导致消耗完内存或者“过度切换”的问题。

【强制】线程池不允许使用 Executors 去创建，而是通过 ThreadPoolExecutor 的方式，这样的处理方式让写的同学更加明确线程池的运行规则，规避资源耗尽的风险。
说明：Executors 返回的线程池对象的弊端如下：
1） FixedThreadPool 和 SingleThreadPool： 允许的请求队列长度为 Integer.MAX_VALUE，可能会堆积大量的请求，从而导致OOM。
2） CachedThreadPool： 允许的创建线程数量为 Integer.MAX_VALUE，可能会创建大量的线程，从而导致 OOM。

自定义线程池代码演示：

public class MainTest {
    public static void main(String[] args) {
        ExecutorService executor1 = null;
        try {
            executor1 = new ThreadPoolExecutor(
                    2,
                    5,
                    1L,
                    TimeUnit.SECONDS,
                    new LinkedBlockingQueue<>(3),
                    Executors.defaultThreadFactory(),
                    new ThreadPoolExecutor.CallerRunsPolicy());
            for (int i = 1; i <= 20; i++) {
                executor1.execute(() -> {
                    System.out.println(Thread.currentThread().getName() + "执行了");
                });
            }
        } finally {
            executor1.shutdown();
        }
    }
}

SpringBoot异步配置，自定义线程池代码演示：

@EnableAsync
@Configuration
public class AsyncConfig {

    /**
     * 线程空闲存活的时间 单位: TimeUnit.SECONDS
     */
    public static final int KEEP_ALIVE_TIME = 60 * 60;
    /**
     * CPU 核心数量
     */
    private static final int CPU_COUNT = Runtime.getRuntime().availableProcessors();
    /**
     * 核心线程数量
     */
    public static final int CORE_POOL_SIZE = Math.max(2, Math.min(CPU_COUNT - 1, 4));
    /**
     * 线程池最大容纳线程数量
     * IO密集型:即存在大量堵塞; 公式: CPU核心数量 / 1- 阻塞系数 (阻塞系统在 0.8~0.9 之间)
     * CPU密集型: 需要大量运算,没有堵塞或很少有; 公式:CPU核心数量 + 1
     */
    public static final int IO_MAXIMUM_POOL_SIZE = (int) (CPU_COUNT / (1 - 0.9));
    public static final int CPU_MAXIMUM_POOL_SIZE = CPU_COUNT + 2;

    /**
     * 执行写入请求时的线程池
     *
     * @return 线程池
     */
    @Bean(name = "iSaveTaskThreadPool")
    public Executor iSaveTaskThreadPool() {
        return getThreadPoolTaskExecutor("iSaveTaskThreadPool-",IO_MAXIMUM_POOL_SIZE,100000,new ThreadPoolExecutor.CallerRunsPolicy());
    }

    /**
     * 执行读请求时的线程池
     *
     * @return 线程池
     */
    @Bean(name = "iQueryThreadPool")
    public Executor iQueryThreadPool() {
        return getThreadPoolTaskExecutor("iQueryThreadPool-",CPU_MAXIMUM_POOL_SIZE,10000,new ThreadPoolExecutor.CallerRunsPolicy());
    }

    /**
     * 创建一个线程池对象
     * @param threadNamePrefix 线程名称
     * @param queueCapacity 堵塞队列长度
     * @param refusePolicy 拒绝策略
     */
    private ThreadPoolTaskExecutor getThreadPoolTaskExecutor(String threadNamePrefix,int maxPoolSize,int queueCapacity,ThreadPoolExecutor.CallerRunsPolicy refusePolicy) {
        ThreadPoolTaskExecutor taskExecutor = new ThreadPoolTaskExecutor();
        taskExecutor.setCorePoolSize(CORE_POOL_SIZE);
        taskExecutor.setMaxPoolSize(maxPoolSize);
        taskExecutor.setKeepAliveSeconds(KEEP_ALIVE_TIME);
        taskExecutor.setThreadNamePrefix(threadNamePrefix);
        // 拒绝策略; 既不会抛弃任务,也不会抛出异常,而是将某些任务回退到调用者,从而降低新任务的流量
        taskExecutor.setRejectedExecutionHandler(refusePolicy);
        // 阻塞队列 长度
        taskExecutor.setQueueCapacity(queueCapacity);
        taskExecutor.setWaitForTasksToCompleteOnShutdown(true);
        taskExecutor.setAwaitTerminationSeconds(60);
        taskExecutor.initialize();
        return taskExecutor;
    }

}
线程池工作原理

在这里插入图片描述

在创建了线程池后，等待提交过来的任务请求，当调用execute方法添加一个请求任务时，线程池会做如下判断：

  1. 如果当前运行的线程数小于corePoolSize，那么马上创建线程运行该任务。
  2. 如果当前运行的线程数大于等于corePoolSize，那么该任务会被放入任务队列。
  3. 如果这时候任务队列满了且正在运行的线程数还小于maximumPoolSize，那么要创建非核心线程立刻运行这个任务扩容。
  4. 如果任务队列满了且正在运行的线程数等于maximumPoolSize，那么线程池会启动饱和拒绝策略来执行。
  5. 随着时间的推移，业务量越来越少，线程池中出现了空闲线程。当一个线程无事可做超过一定的时间时，线程池会进行判断，如果当前运行的线程数大于corePoolSize，那么这个线程就被停掉，所以线程池的所有任务完成后它最终会收缩到corePoolSize的大小。
阻塞队列

阻塞队列，顾名思义，首先它是一个队列，一个阻塞队列在数据结构中所起的作用：

  • 当阻塞队列是空时，从队列中获取元素的操作将会被阻塞。
  • 当阻塞队列是满时，往队列里添加元素的操作将会被阻塞。

在这里插入图片描述

在多线程编程中，阻塞队列扮演着重要角色，特别适用于生产者-消费者模式，确保线程之间的同步和有序执行。阻塞队列的本质是一种数据结构，用于存储待执行的任务。当任务提交给线程池时，如果核心线程已满或任务队列达到容量上限，新任务将被放入阻塞队列中，等待执行条件的满足。

阻塞在多线程领域指的是线程因某些条件而暂停执行，一旦条件满足，线程会被自动唤醒继续执行。这种机制保证了线程池的任务按照预期顺序执行，有效地管理并发任务的执行流程。

在Java中，常见的线程池阻塞队列包括：

  • ArrayBlockingQueue: 由数组结构组成的有界阻塞队列。它按照 FIFO（先进先出）的顺序对元素进行排序。
  • LinkedBlockingQueue: 由链表结构组成的有界（默认大小为 Integer.MAX_VALUE，大约21亿）阻塞队列。同样按照 FIFO 的顺序对元素进行排序。
  • PriorityBlockingQueue: 支持优先级排序的无界阻塞队列。元素按照它们的优先级顺序被处理，具有最高优先级的元素总是被队列中的下一个要处理的元素。
  • DelayQueue: 使用优先级队列实现的延迟无界阻塞队列。队列中的元素只有在其指定的延迟时间到达时才能被取出。
  • SynchronousQueue: 不存储元素的阻塞队列，每个插入操作必须等待一个对应的移除操作。用于直接传递任务的场景。
  • LinkedTransferQueue: 由链表结构组成的无界阻塞队列，支持生产者-消费者的传输机制。与其他队列不同，它支持优先级传输。
  • LinkedBlockingDeque: 由链表结构组成的双向阻塞队列。它支持在队列的两端进行插入和移除操作，是一种双端队列。

当你自定义线程池时，选择合适的阻塞队列是非常重要的。阻塞队列就像一个存放任务的“箱子”，线程池中的任务先放到这里，然后线程池的线程再从这里取出来执行。如果你的系统可能会有很多任务一起提交，可以考虑用能存很多任务的队列，比如LinkedBlockingQueue。这样即使任务多了，也不会丢失。如果你的任务有优先级，比如有些任务比其他的更重要，那就选PriorityBlockingQueue。它会按照任务的优先级来决定哪个任务先执行。如果应用程序需要限制内存使用，并希望在达到容量限制时阻塞新任务提交，可以选择ArrayBlockingQueue。

线程池参数

在Java中，线程池的创建和管理通过java.util.concurrent.ThreadPoolExecutor类完成。理解这个类构造函数的参数可以帮助我们更好地配置和优化线程池的运行效果。

public ThreadPoolExecutor(int corePoolSize,
                          int maximumPoolSize,
                          long keepAliveTime,
                          TimeUnit unit,
                          BlockingQueue<Runnable> workQueue,
                          ThreadFactory threadFactory,
                          RejectedExecutionHandler handler) {
             // ...
}
  • corePoolSize: 核心线程数。当提交一个新任务时，如果当前运行的线程少于corePoolSize，则即使有空闲的工作线程，也会创建一个新线程来执行任务。核心线程在ThreadPoolExecutor的生命周期内始终存活，除非设置了allowCoreThreadTimeOut。
  • maximumPoolSize：线程池能够容纳同时执行的最大线程数，此值必须大于等于1。当任务队列满时，如果当前运行的线程数少于maximumPoolSize，则会创建新的线程来执行任务。
  • threadFactory：线程工厂，一般用默认的即可。用于创建新线程，通常用来给线程设置名称、设置为守护线程等。
  • workQueue：任务队列，用于保存等待执行任务的队列。随着业务量的增多，线程开始慢慢处理不过来，这时候需要放到任务队列中去等待线程处理。
  • rejectedExecutionHandler：拒绝策略。如果业务越来越多，线程池首先会扩容，扩容后发现还是处理不过来，任务队列已经满了，处理被拒绝任务的策略。
    1. AbortPolicy: 默认拒绝策略；直接抛出java.util.concurrent.RejectedExecutionException异常，阻止系统的正常运行；
    2. CallerRunsPolicy：调用这运行，一种调节机制，该策略既不会抛弃任务，也不会抛出异常，而是将某些任务回退到调用者，从而降低新任务的流量；
    3. DiscardOldestPolicy：抛弃队列中等待最久的任务，然后把当前任务加入到队列中；
    4. DiscardPolicy：直接丢弃任务，不给予任何处理也不会抛出异常；如果允许任务丢失，这是一种最好的解决方案；
  • keepAliveTime：多余的空闲线程的存活时间。如果线程池扩容后，能处理过来，而且数据量并没有那么大，用最初的线程数量就能处理过来，剩下的线程被叫做空闲线程。keepAliveTime指的是当线程数超过corePoolSize时，多余的空闲线程在等待新任务到来之前可以存活的最长时间。如果设置为0，则超出核心线程数的空闲线程会立即终止。
  • unit：keepAliveTime参数的时间单位，可以是TimeUnit.SECONDS、TimeUnit.MILLISECONDS等。
合理配置线程池参数

合理配置线程池参数，可以分为以下两种情况：

  • CPU密集型：CPU密集的意思是该任务需要大量的运算，而没有阻塞，CPU一直全速运行；CPU密集型任务配置尽可能少的线程数量：参考公式：（CPU核数+1）
  • IO密集型：即该任务需要大量的IO，即大量的阻塞；在IO密集型任务中使用多线程可以大大的加速程序运行，故需要多配置线程数：参考公式：CPU核数/ (1-阻塞系数) 阻塞系数在0.8~0.9之间
public class MainTest {
    public static void main(String[] args) {
        ExecutorService executor1 = null;
        try {
            // 获取CPU核心数
            int coreNum = Runtime.getRuntime().availableProcessors();
            /*
             * 1. IO密集型: CPU核数/ (1-阻塞系数) 阻塞系数在0.8~0.9之间
             * 2. CPU密集型: CPU核数+1
             */
//            int maximumPoolSize = coreNum + 1;
            int maximumPoolSize = (int) (coreNum / (1 - 0.9));
            System.out.println("当前线程池最大允许存放：" + maximumPoolSize + "个线程");
            executor1 = new ThreadPoolExecutor(
                    2,
                    maximumPoolSize,
                    1L,
                    TimeUnit.SECONDS,
                    new LinkedBlockingQueue<>(3),
                    Executors.defaultThreadFactory(),
                    new ThreadPoolExecutor.CallerRunsPolicy());
            for (int i = 1; i <= 20; i++) {
                executor1.execute(() -> {
                    System.out.println(Thread.currentThread().getName() + "执行了");
                });
            }
        } finally {
            executor1.shutdown();
        }
    }
}
_whitepure
关注
  • 15
    点赞
  • 踩
  • 16
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
Java线程的创建方式
m0_54202121的博客
04-24 2277
7.Callable&Future 接口 ​ 目前我们学习了有两种创建线程的方法-一种是通过创建 Thread 类，另一种是通过使用 Runnable 创建线程。但是，Runnable 缺少的一项功能是，当线程终止时（即 run（）完成时），我们无法使线程返回结果。为了支持此功能， Java 中提供了 Callable 接口。 现在我们学习的是创建线程的第三种方案—Callable 接口 Callable 接口的特点如下(重点) • 为了实现 Runnable，需要实现不返回任何内容的 run（）方
java创建线程的四种方式
weixin_45861045的博客
06-13 2200
java创建线程的四种方式
Java中创建线程的三种方式
忆晨的博客
09-06 9416
创建线程的三种方式
java创建线程的三种方式
热门推荐
qq_50867577的博客
06-05 1万+
线程创建的三种方式及其对比
java中创建线程的4种方式
wolf的博客
04-25 5079
写在前面的话 java线程创建方式有几种？这种问题在面试中经常被问到，你可能心里马上反映出两种方式（实现Runnable、继承Thread），当你把这两种叙述给面试官听后，面试官会觉得你该掌握的知识已经有了，但是仅仅而已。如果你还说了callable与future、线程池，那么面试官就会认为你 知识覆盖面广，对你好感加一！下面首先叙述为什么会出现线程，以及线程在实际生活中的例子，紧接着给出四种创...
java创建多线程的四种方式
weixin_48016395的博客
02-15 4696
java多线程的创建方式是面试经常会被问到的一个问题，因此在这里我对java创建多线程的四种方式做一个简单的归纳与总结，便于复习。 一、继承Thread类创建多线程 ① 创建一个继承于Thread类的子类。 ② 重写Thread类中的run()方法，在run()方法中实现线程需要完成的功能。 ③ 创建Thread类的子类的对象，并调用这个对象的start()方法，调用start()后会自动启动当前线程，并调用当前线程的run()方法。 ...
Java多线程 - Java创建线程的4种方式
你今天真好看呀
02-18 9663
文章目录1. Java创建线程有哪几种方式？1.1 线程创建方法一：继承Thread类创建线程类1.2 线程创建方法二：实现Runnable接口创建线程目标类1.3 优雅创建Runnable线程目标类的两种方式1.4 通过实现Runnable接口的方式创建线程目标类的优缺点1.5 线程创建方法三：使用Callable和FutureTask创建线程1.6 线程创建方法四：通过线程池创建线程2. 线程的 run() 和 start() 有什么区别？3. Runnable 和 Thread 用哪个好？4. Fut
java创建线程的方式有几种？
禾日香的博客
03-06 1232
java创建线程的方式有几种？这四种究其底层都是实现Runnable接口实现的。
Java 中创建线程的几种方式
Java徐师兄的博客
04-27 2824
Java 中创建线程的几种方式
【Java】创建多线程的四种方式
酷奇的博客
02-27 3254
每个线程都有一定的优先级，同优先级线程组成先进先出队列（先到先服务），使用分时调度策略。优先级高的线程采用抢占式策略，获得较多的执行机会。每个线程默认的优先级都与创建它的父线程具有相同的优先级。当多个线程同时操作同一个共享数据时，就会出现线程的安全问题。
Java创建线程的两种方式
09-01
在Java编程中，创建线程是实现并发执行任务的关键。Java提供了两种主要的方式来创建线程，分别是继承`Thread`类和实现`Runnable`接口。这两种方式各有优缺点，适用于不同的场景。 ### 继承Thread类 当你选择继承`...
java 创建线程的几种方式
08-31
在Java编程语言中，创建线程是实现多任务并发处理的关键。本文将详细阐述两种主要的线程创建方式，以及它们的特点和使用场景。 首先，第一种创建线程的方式是通过继承`java.lang.Thread`类。当你创建一个新的类并...
Java使用Callable和Future创建线程操作示例
08-25
Java使用Callable和Future创建线程操作示例主要介绍了Java使用Callable和Future创建线程操作，结合实例形式分析了java使用Callable接口和Future类创建线程的相关操作技巧与注意事项。 首先，Java 5开始，Java提供了...
java Runnable接口创建线程
08-30
Java中的线程创建方式有多种，其中使用Runnable接口创建线程是一种最常用的方式。本文将详细介绍Java Runnable接口创建线程的相关知识点。 什么是Runnable接口 Runnable接口是Java语言中用于创建线程的接口。该...
Java创建子线程的两种方法
08-19
实现 Runnable 接口是创建子线程的另一种方法，这种方法需要实现 Runnable 接口，然后通过 Thread(Runnable target) 来创建线程。这种方法的优点是灵活多样，可以多继承，适合处理多个线程共享数据的情况。 public ...
ORA-03113 end-of-file on communication channel
努力分享一些干货内容，纯干货，没有一点水
07-29 4926
文章目录问题问题原因问题解决删除归档日志增加归档日志空间参考文章 问题 用数据库连接工具发现数据库连接不上了，登陆服务器一看发现数据库满了 登陆root或oracle用户；登陆root需要切换到oracle：su - oracle； 使用 sqlplus / as sysdba 命令切换到sqlplus； 在 sqlplus 模式下使用startup命令，开启数据库。发现启动报错： 问题原因 在网上简单搜了一下，原因是Oracle 数据库归档日志满了。用df -h命令看了一下磁盘空间占用情况，磁盘已经满
gitlab-runner 设置用户为root
努力分享一些干货内容，纯干货，没有一点水
08-16 4338
安装gitlab-runner默认会将用户设置为：gitlab-runner，该设置会使编写.ci的脚本，操作带来很大不便，本人深受其害。 1.通过ps aux|grep gitlab-runner命令查看gitlab-runner进程，可以查看到gitlab-runner的工作目录和默认用户等一系列相关信息。 2.通过该命令sudo gitlab-runner uninstall可以删除掉gitlab-runner 3.重新安装gitlab-runner并将用户设置为rootgitlab-runner i
Nginx入门
最新发布
努力分享一些干货内容，纯干货，没有一点水
05-05 2147
Nginx是一个高性能的Web服务器和反向代理服务器，特点是占有内存少，并发能力强，Nginx的并发能力确实在同类型的网页服务器中表现较好。Nginx专为性能优化而开发，性能是其最重要的考量，实现上非常注重效率，能经受高负载的考验，有报告表明能支持高达50000个并发连接数。常用于处理大量的并发连接。它也可以用作负载均衡器和HTTP缓存。它因其高效的性能、灵活的配置和低资源消耗而受到广泛欢迎。Nginx能够作为Web服务器，高效地提供静态文件，如HTMLCSSJavaScript。
如何减少bug及解决bug思路
努力分享一些干货内容，纯干货，没有一点水
05-05 2057
减少bug的出现只能多测多验证，哪怕单元测试通过都不能非常有效减少bug，因为受到写单元测试的人的思维角度限制，导致单元测试的片面性。1945年，一只小飞蛾钻进了计算机电路里，导致系统无法工作，一位名叫格蕾丝·赫柏的人把飞蛾拍死在工作日志上，写道：就是这个 bug(虫子)，害我们今天的工作无法完成——于是，bug一词成了电脑系统程序的专业术语，形容那些系统中的缺陷或问题。关于bug的种类，最容易出现的bug是逻辑上的bug，如复杂庞大一点软件如果不是所有地方都熟悉就写代码是比较容易遗漏一些特殊情况的。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

_whitepure

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值