8 篇笔记 写笔记

1. #0

   dg5uw

   159***[email protected]

   204

   线程池

   1、线程池,其实就是一个容纳多个线程的容器,其中的线程可以反复使用,省去了频繁创建线程对象的操作,无需反复创建线程而消耗过多资源。(是什么)

   2、那么,我们为什么需要用到线程池呢?每次用的时候手动创建不行吗?

   在java中,如果每个请求到达就创建一个新线程,开销是相当大的。在实际使用中,创建和销毁线程花费的时间和消耗的系统资源都相当大,甚至可能要比在处理实际的用户请求的时间和资源要多的多。除了创建和销毁线程的开销之外,活动的线程也需要消耗系统资源。如果在一个jvm里创建太多的线程,可能会使系统由于过度消耗内存或"切换过度"而导致系统资源不足。为了防止资源不足,需要采取一些办法来限制任何给定时刻处理的请求数目,尽可能减少创建和销毁线程的次数,特别是一些资源耗费比较大的线程的创建和销毁,尽量利用已有对象来进行服务。(为什么)

   线程池主要用来解决线程生命周期开销问题和资源不足问题。通过对多个任务重复使用线程,线程创建的开销就被分摊到了多个任务上了,而且由于在请求到达时线程已经存在,所以消除了线程创建所带来的延迟。这样,就可以立即为请求服务,使用应用程序响应更快;另外,通过适当的调整线程中的线程数目可以防止出现资源不足的情况。(什么用)

   3、线程池都是通过线程池工厂创建,再调用线程池中的方法获取线程,再通过线程去执行任务方法。

   • Executors:线程池创建工厂类
   • public static ExecutorServicenewFixedThreadPool(int nThreads):返回线程池对象
   • ExecutorService:线程池类
   • Future<?> submit(Runnable task):获取线程池中的某一个线程对象,并执行
   • Future 接口:用来记录线程任务执行完毕后产生的结果。线程池创建与使用

   4、这里介绍两种使用线程池创建线程的方法

   1):使用Runnable接口创建线程池

   使用线程池中线程对象的步骤:

   • 1、创建线程池对象
   • 2、创建 Runnable 接口子类对象
   • 3、提交 Runnable 接口子类对象
   • 4、关闭线程池

   Test.java 代码如下:

   import java.util.concurrent.ExecutorService;
   import java.util.concurrent.Executors;
   public class Test {
    public static void main(String[] args) {
    //创建线程池对象 参数5,代表有5个线程的线程池
    ExecutorService service = Executors.newFixedThreadPool(5);
    //创建Runnable线程任务对象
    TaskRunnable task = new TaskRunnable();
    //从线程池中获取线程对象
    service.submit(task);
    System.out.println("----------------------");
    //再获取一个线程对象
    service.submit(task);
    //关闭线程池
    service.shutdown();
    }
   }

   TaskRunnable.java 接口文件如下:

   public class TaskRunnable implements Runnable{
    @Override
    public void run() {
    for (int i = 0; i < 1000; i++) {
    System.out.println("自定义线程任务在执行"+i);
    }
    }
   }

   2)使用Callable接口创建线程池

   Callable接口:与Runnable接口功能相似,用来指定线程的任务。其中的call()方法,用来返回线程任务执行完毕后的结果,call方法可抛出异常。

   ExecutorService:线程池类

   <T> Future<T> submit(Callable<T> task):获取线程池中的某一个线程对象,并执行线程中的 call() 方法

   Future 接口:用来记录线程任务执行完毕后产生的结果。线程池创建与使用

   使用线程池中线程对象的步骤:

   • 1、创建线程池对象
   • 2、创建 Callable 接口子类对象
   • 3、提交 Callable 接口子类对象
   • 4、关闭线程池

   Test.java 代码如下:

   import java.util.concurrent.ExecutorService;
   import java.util.concurrent.Executors;
   public class Test{
    public static void main(String[] args) {
    ExecutorService service = Executors.newFixedThreadPool(3);
    TaskCallable c = new TaskCallable();
    //线程池中获取线程对象,调用run方法
    service.submit(c);
    //再获取一个
    service.submit(c);
    //关闭线程池
    service.shutdown();
    }
   }

   TaskCallable.java 接口文件如下:

   import java.util.concurrent.Callable;
   public class TaskCallable implements Callable<Object>{
    @Override
    public Object call() throws Exception {
    for (int i = 0; i < 1000; i++) {
    System.out.println("自定义线程任务在执行"+i);
    }
    return null;
    }
   }

   dg5uw

   159***[email protected]

   8年前 (2018年03月05日)
2. #0

   dg5uw

   159***[email protected]

   54

   线程池练习:返回两个数相加的结果

   要求:通过线程池中的线程对象,使用Callable接口完成两个数求和操作

   Future 接口:用来记录线程任务执行完毕后产生的结果。

   线程池创建与使用:get() 获取 Future对象中封装的数据结果

   ThreadPoolDemo.java 文件代码如下:

   import java.util.concurrent.ExecutionException;
   import java.util.concurrent.ExecutorService;
   import java.util.concurrent.Executors;
   import java.util.concurrent.Future;
   public class ThreadPoolDemo {
    public static void main(String[] args) throws InterruptedException, ExecutionException {
    //创建线程池对象
    ExecutorService threadPool = Executors.newFixedThreadPool(2);
    
    //创建一个Callable接口子类对象
    //MyCallable c = new MyCallable();
    MyCallable c = new MyCallable(100, 200);
    MyCallable c2 = new MyCallable(10, 20);
    
    //获取线程池中的线程,调用Callable接口子类对象中的call()方法, 完成求和操作
    //<Integer> Future<Integer> submit(Callable<Integer> task)
    // Future 结果对象
    Future<Integer> result = threadPool.submit(c);
    //此 Future 的 get 方法所返回的结果类型
    Integer sum = result.get();
    System.out.println("sum=" + sum);
    
    //再演示
    result = threadPool.submit(c2);
    sum = result.get();
    System.out.println("sum=" + sum);
    //关闭线程池(可以不关闭)
    
    }
   }

   MyCallable.java 接口文件代码如下:

   import java.util.concurrent.Callable;
   public class MyCallable implements Callable<Integer> {
    //成员变量
    int x = 5;
    int y = 3;
    //构造方法
    public MyCallable(){
    }
    public MyCallable(int x, int y){
    this.x = x;
    this.y = y;
    }
    @Override
    public Integer call() throws Exception {
    return x+y;
    }
   }

   dg5uw

   159***[email protected]

   8年前 (2018年03月05日)
3. #0

   0°Cspace

   960***[email protected]

   31

   进程和线程的区别

   进程

   应用程序的执行实例,有独立的内存空间和系统资源

   线程

   CPU调度和分派的基本单位,进程中执行运算的最小单位,可完成一个独立的顺序控制流程

   进程和线程的关系

   (1)一个线程只能属于一个进程,而一个进程可以有多个线程,但至少有一个线程。线程是操作系统可识别的最小执行和调度单位。

   (2)资源分配给进程,同一进程的所有线程共享该进程的所有资源。 同一进程中的多个线程共享代码段(代码和常量),数据段(全局变量和静态变量),扩展段(堆存储)。但是每个线程拥有自己的栈段,栈段又叫运行时段,用来存放所有局部变量和临时变量。

   (3)处理机分给线程,即真正在处理机上运行的是线程。

   (4)线程在执行过程中,需要协作同步。不同进程的线程间要利用消息通信的办法实现同步。

   0°Cspace

   960***[email protected]

   8年前 (2018年03月23日)
4. #0

   阿颖

   553***[email protected]

   参考地址

   37

   Java Thread 中 run() 与 start() 的区别

   Java 的线程是通过 java.lang.Thread 类来实现的。VM 启动时会有一个由主方法所定义的线程。可以通过创建 Thread 的实例来创建新的线程。每个线程都是通过某个特定 Thread 对象所对应的方法 run() 来完成其操作的,方法 run() 称为线程体。通过调用 Thread 类的 start() 方法来启动一个线程。

   在 Java 当中,线程通常都有五种状态,创建、就绪、运行、阻塞和死亡。

   • 第一是创建状态。在生成线程对象,并没有调用该对象的 start 方法,这是线程处于创建状态。
   • 第二是就绪状态。当调用了线程对象的 start 方法之后,该线程就进入了就绪状态,但是此时线程调度程序还没有把该线程设置为当前线程,此时处于就绪状态。在线程运行之后,从等待或者睡眠中回来之后,也会处于就绪状态。
   • 第三是运行状态。线程调度程序将处于就绪状态的线程设置为当前线程,此时线程就进入了运行状态,开始运行 run 函数当中的代码。
   • 第四是阻塞状态。线程正在运行的时候,被暂停,通常是为了等待某个时间的发生(比如说某项资源就绪)之后再继续运行。sleep,suspend,wait 等方法都可以导致线程阻塞。
   • 第五是死亡状态。如果一个线程的 run 方法执行结束或者调用 stop 方法后,该线程就会死亡。对于已经死亡的线程,无法再使用 start 方法令其进入就绪。

   实现并启动线程有两种方法

   • 1、写一个类继承自 Thread 类,重写 run 方法。用 start 方法启动线程
   • 2、写一个类实现 Runnable 接口,实现 run 方法。用 new Thread(Runnable target).start() 方法来启动

   多线程原理:相当于玩游戏机,只有一个游戏机(cpu),可是有很多人要玩,于是,start 是排队!等 CPU 选中你就是轮到你,你就 run(),当 CPU 的运行的时间片执行完,这个线程就继续排队,等待下一次的run()。

   调用 start() 后,线程会被放到等待队列,等待 CPU 调度,并不一定要马上开始执行,只是将这个线程置于可动行状态。然后通过 JVM,线程 Thread 会调用 run() 方法,执行本线程的线程体。先调用 start 后调用 run,这么麻烦,为了不直接调用 run?就是为了实现多线程的优点,没这个 start 不行。

   • 1.start() 方法来启动线程,真正实现了多线程运行。这时无需等待 run 方法体代码执行完毕,可以直接继续执行下面的代码;通过调用 Thread 类的 start() 方法来启动一个线程, 这时此线程是处于就绪状态, 并没有运行。 然后通过此 Thread 类调用方法 run() 来完成其运行操作的, 这里方法 run() 称为线程体,它包含了要执行的这个线程的内容, run 方法运行结束, 此线程终止。然后 CPU 再调度其它线程。
   • 2.run() 方法当作普通方法的方式调用。程序还是要顺序执行,要等待 run 方法体执行完毕后,才可继续执行下面的代码; 程序中只有主线程——这一个线程, 其程序执行路径还是只有一条, 这样就没有达到写线程的目的。

   记住:多线程就是分时利用 CPU,宏观上让所有线程一起执行 ,也叫并发。

   public class Test {
    public static void main(String[] args) {
    Runner1 runner1 = new Runner1();
    Runner2 runner2 = new Runner2();
   // Thread(Runnable target) 分配新的 Thread 对象。
    Thread thread1 = new Thread(runner1);
    Thread thread2 = new Thread(runner2);
   // thread1.start();
   // thread2.start();
    thread1.run();
    thread2.run();
    }
   }
    
   class Runner1 implements Runnable { // 实现了Runnable接口,jdk就知道这个类是一个线程
    public void run() {
    for (int i = 0; i < 100; i++) {
    System.out.println("进入Runner1运行状态——————————" + i);
    }
    }
   }
    
   class Runner2 implements Runnable { // 实现了Runnable接口,jdk就知道这个类是一个线程
    public void run() {
    for (int i = 0; i < 100; i++) {
    System.out.println("进入Runner2运行状态==========" + i);
    }
    }
   }

   阿颖

   阿颖

   553***[email protected]

   参考地址

   8年前 (2018年08月13日)
5. #0

   HelloWorld

   zhy***@qq.com

   参考地址

   34

   线程状态图:

   线程共包括以下 5 种状态:

   1. 新建状态(New): 线程对象被创建后,就进入了新建状态。例如,Thread thread = new Thread()。

   2. 就绪状态(Runnable): 也被称为"可执行状态"。线程对象被创建后,其它线程调用了该对象的start()方法,从而来启动该线程。例如,thread.start()。处于就绪状态的线程,随时可能被CPU调度执行。

   3. 运行状态(Running): 线程获取CPU权限进行执行。需要注意的是,线程只能从就绪状态进入到运行状态。

   4. 阻塞状态(Blocked): 阻塞状态是线程因为某种原因放弃CPU使用权,暂时停止运行。直到线程进入就绪状态,才有机会转到运行状态。阻塞的情况分三种:

   • (01) 等待阻塞 -- 通过调用线程的wait()方法,让线程等待某工作的完成。
   • (02) 同步阻塞 -- 线程在获取synchronized同步锁失败(因为锁被其它线程所占用),它会进入同步阻塞状态。
   • (03) 其他阻塞 -- 通过调用线程的sleep()或join()或发出了I/O请求时,线程会进入到阻塞状态。当sleep()状态超时、join()等待线程终止或者超时、或者I/O处理完毕时,线程重新转入就绪状态。

   5. 死亡状态(Dead): 线程执行完了或者因异常退出了run()方法,该线程结束生命周期。

   HelloWorld

   HelloWorld

   zhy***@qq.com

   参考地址

   8年前 (2018年09月04日)
6. #0

   cz

   109***[email protected]

   37

   线程安全问题

   产生原因:多个线程竞争同一资源(访问同一数据),可参考经典的生产者消费者问题。

   解决方案:

   run 方法内:同步代码块 synchronized {}

   Public synchronized 返回值类型 方法名(){} 自动释放对象锁

   使用 Lock 锁

   Lock 锁需要程序员(在 finally 代码块中)手动释放。

   Lock lock=new ReentranttLock() // Reentrant(可重用的)

   Lock 实现提供了比使用 synchronized 方法和语句可获得的更广泛的锁定操作,是 JDK1.5 之后出现的。

   Lock 接口中的方法:

   void lock() // 获取锁 
   void unlock() // 释放锁 

   Lock 接口的实现类:

   java.util.concurrent.locks.ReentrantLock implements Lock

   使用步骤:

   • 1.在成员位置创建一个 ReentrantLock 对象。
   • 2.在可能出现线程安全问题的代码前,调用 Lock 接口中的方法 lock 获取锁对象。
   • 3.在可能出现线程安全问题的代码后,调用 Lock 接口中的方法 unlock 释放锁对象。

   public class RunnableImpl implements Runnable{
    //定义一个共享的票源
    private int ticket = 100;
    //1.在成员位置创建一个ReentrantLock对象
    Lock l = new ReentrantLock();
    //设置线程任务:卖票
    @Override
    public void run() {
    //使用死循环,让卖票重复的执行
    while(true){
    //2.在可能出现线程安全问题的代码前,调用Lock接口中的方法lock获取锁对象
    l.lock();
    //判断票是否大于0
    if(ticket>0){
    //为了提高线程安全问题出现的几率,让程序睡眠10毫秒
    try {
    //可能会产生异常的代码
    Thread.sleep(10);
    //进行卖票 ticket--
    System.out.println(Thread.currentThread().getName()+"正在卖第"+ticket+"张票!");
    ticket--;
    } catch (InterruptedException e) {
    //异常的处理逻辑
    e.printStackTrace();
    }finally {
    //一定会执行的代码,一般用于资源释放(资源回收)
    //3.在可能出现线程安全问题的代码后,调用Lock接口中的方法unlock释放锁对象
    l.unlock();//无论程序是否有异常,都让锁对象释放掉,节约内存,提高程序的效率
    }
    }
    }
    }
   }

   cz

   109***[email protected]

   8年前 (2018年11月06日)
7. #0

   我v成为v我v成为

   201***[email protected]

   28

   用 CompletableFuture 来解决回调的问题。

   import java.util.concurrent.CompletableFuture;
   import java.util.concurrent.CountDownLatch;
   public class CompletableFutureDemo {
    public static void main(String[] args) throws InterruptedException {
    long l = System.currentTimeMillis();
    CompletableFuture<Integer> completableFuture = CompletableFuture.supplyAsync(() -> {
    System.out.println("执行耗时操作...");
    timeConsumingOperation();
    return 100;
    });
    completableFuture.whenComplete((result, e) -> {
    System.out.println("结果:" + result);
    });
    System.out.println("主线程运算耗时:" + (System.currentTimeMillis() - l) + " ms");
    new CountDownLatch(1).await();
    }
    static void timeConsumingOperation() {
    try {
    Thread.sleep(3000);
    } catch (Exception e) {
    e.printStackTrace();
    }
    }
   }

   控制台输出:

   执行耗时操作...
   主线程运算耗时:74 ms
   结果:100

   可以发现耗时操作没有占用主线程的时间片,达到了异步调用的效果。我们也不需要引入任何第三方的依赖,这都是依赖于 java.util.concurrent.CompletableFuture 的出现。CompletableFuture 提供了近 50 多个方法,大大便捷了 java 多线程操作,和异步调用的写法。

   我v成为v我v成为

   201***[email protected]

   7年前 (2019年06月11日)
8. #0

   八云式

   139***[email protected]

   参考地址

   32

   关于java的多线程,这里补充一下Object类的线程方法。

   notify() :通知一个在对象上等待的线程,使其从wait()返回,而返回的前提是该线程获取到了对象的锁。

   notifyAll(): 通知所有等待在该对象上的线程。

   wait():调用该方法的线程进入WAITING状态,只有等待另外线程的通知或被中断才会返回,需要注意,

   调用wait()方法后,会释放对象的锁。

   wait(long) :超时等待一段时间,这里的参数是毫秒,也就是等待长达n毫秒,如果没有通知就超时返回。

   wait(long, int) : 对于超时时间更细粒度的控制,可以达到毫秒。

   八云式

   139***[email protected]

   参考地址

   6年前 (2020年03月21日)