多线程、线程池、锁

最新推荐文章于 2022-03-25 11:34:44 发布
最新推荐文章于 2022-03-25 11:34:44 发布
阅读量110 收藏
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44554530/article/details/118121119
版权

多线程

进程与线程

进程

进程是程序资源分配的基本单位、执行时的一个实例 在程序运行的时候就会产生一个进程，这个进程不会马上运行会进入就绪状态并进入队列中，在为它分配cpu时间的时候才会真正开始运行

线程

线程是一条执行路径，是操作系统可识别的最小执行和调度单位，它是进程的一个执行流，是CPU调度和分派的基本单位，一个进程可以由很多个线程组成，线程间共享进程的所有资源，每个线程有自己的堆栈和局部变量,他们直接相互独立互不影响

进程与线程的关系：一个进程包含多个线程，进程是一个正在执行的程序，线程是一个能够被分配的资源单位，也可以称作一个任务

线程的生命周期

  1. 创建（new）: 准备好了一个多线程的对象，也就是说执行了一个new Thread(); 创建完成后就需要为线程分配内存
  2. 就绪（runnable）: 调用了start()方法, 等待CPU进行调度
  3. 运行（running）: 执行run()方法
  4. 阻塞（blocked）: 暂时停止执行线程，将线程挂起(sleep()、wait()、join()、没有获取到锁都会使线程阻塞), 可能将资源交给其它线程使用
  5. 死亡（terminated）: 线程销毁(正常执行完毕、发生异常或者被打断interrupt()都会导致线程终止)

在这里插入图片描述

多线程并发编程的好处

我们的程序是从上往下以此执行，多线程的存在可以让我们在相同的时间里做多个操作，将程序的资源最大化的利用以此来提高我们程序的效率：

public static void main(String[] args) throws Exception{
        new Thread(() -> {
            try{
                System.out.println(Thread.currentThread().getName()+"吃饭");
                Thread.sleep(10000);
                System.out.println(Thread.currentThread().getName()+"睡觉");
            }catch (InterruptedException e){}
        },"Thread-01").start();

        new Thread(() -> {
            try{
                System.out.println(Thread.currentThread().getName()+"吃饭");
                Thread.sleep(5000);
                System.out.println(Thread.currentThread().getName()+"睡觉");
            }catch (InterruptedException e){}
        },"Thread-02").start();
    }

在这里插入图片描述

创建线程的方式

  1. 继承Thread类
  2. 实现Runable接口
  3. 实现Callable接口

Thread

public class Main {
    public static void main(String[] args) {
    	//通过继承Thread类, 重写run()方法
    	//调用start方法让线程进入就绪状态等待cpu调度
        new DemoThread().start();
        
		//匿名内部类
        new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName());
            }
        }).start();

  }
}

class DemoThread extends Thread {
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName());
    }
}

Runable

public class Main {
    public static void main(String[] args) {
    	//将Runnable实现类作为Thread的构造参数传递到Thread类中
    	//启动Thread类
        DemoThread runnable = new DemoThread();
        new Thread(runnable).start();
		
		// Runnable是函数式接口，所以可以使用Lamda表达式形式
        Runnable runnable = () -> {
        	System.out.println(Thread.currentThread().getName());
        };
        new Thread(runnable).start();

    }
}

class DemoThread implements Runable {
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName());
    }
}

Callable

实现Callable接口，重写call()方法，然后包装成java.util.concurrent.FutureTask, 再然后包装成Thread

public class Main {
    public static void main(String[] args) throws Exception {
    	 // 将Callable包装成FutureTask，FutureTask也是一种Runnable
        DemoCallable callable = new DemoCallable();
        FutureTask<Integer> futureTask = new FutureTask<>(callable);
        new Thread(futureTask).start();

        // get方法会阻塞调用的线程
        Integer sum = futureTask.get();
        System.out.println(Thread.currentThread().getName());
        System.out.println(sum);
    }
}


class DemoCallable implements Callable<Integer> {

    @Override
    public Integer call() throws Exception {
        System.out.println(Thread.currentThread().getName());

        int sum = 0;
        for (int i = 0; i <= 100000; i++) {
            sum += i;
        }
        Thread.sleep(5000);

        System.out.println(Thread.currentThread().getName());
        return sum;
    }
}


Thread-0
Thread-0
main
705082704
  1. Thread: 继承方式, 不建议使用, 因为Java是单继承的，继承了Thread就没办法继承其它类了，不够灵活
  2. Runnable: 实现接口，比Thread类更加灵活，没有单继承的限制
  3. Callable: Thread和Runnable都是重写的run()方法并且没有返回值，Callable是重写的call()方法并且有返回值并可以借助FutureTask类来判断线程是否已经执行完毕或者取消线程执行
public class FutureTask<V> implements RunnableFuture<V> {
	// 构造函数
	public FutureTask(Callable<V> callable);
	
	// 取消线程
	public boolean cancel(boolean mayInterruptIfRunning);
	// 判断线程
	public boolean isDone();
	// 获取线程执行结果
	public V get() throws InterruptedException, ExecutionException;
}

Thread常用方法

// main方法就是一个主线程
public static void main(String[] args) {
    // 获取当前正在运行的线程
    Thread thread = Thread.currentThread();
    // 线程名字
    String name = thread.getName();
    // 线程id
    long id = thread.getId();
    // 线程优先级
    int priority = thread.getPriority();
    // 是否存活
    boolean alive = thread.isAlive();
    // 是否守护线程
    boolean daemon = thread.isDaemon();

}

start()

start是启动一个线程，线程之间是没有顺序的，是按CPU分配的时间片来回切换的，调用start()是一种并发编程

public static void main(String[] args) throws Exception {
   new Thread(()-> {
       for (int i = 0; i < 5; i++) {
           System.out.println(Thread.currentThread().getName() + " " + i);
           
       }
   }, "Thread-A").start();

   new Thread(()-> {
       for (int j = 0; j < 5; j++) {
           System.out.println(Thread.currentThread().getName() + " " + j);
       }
   }, "Thread-B").start();

//out
Thread-A 0
Thread-B 0
Thread-A 1
Thread-B 1
Thread-A 2
Thread-B 2
Thread-B 3
Thread-A 3
Thread-B 4
Thread-A 4

run()

run是调用线程的run方法，就是普通的方法调用，而调用run()方法就是一种顺序编程不是并发编程

public static void main(String[] args) throws Exception{
        new Thread(()-> {
       for (int i = 0; i < 5; i++) {
         System.out.println(Thread.currentThread().getName() + " " + i);
            }
       }, "Thread-A").run();

        new Thread(()-> {
       for (int j = 0; j < 5; j++) {
         System.out.println(Thread.currentThread().getName() + " " + j);
       }
        }, "Thread-B").run();

    }
//out 都是main主线程
main 1
main 2
main 3
main 4
main 0
main 1
main 2
main 3
main 4

sleep()

睡眠指定时间，程序暂停运行，睡眠期间会让出CPU的执行权，去执行其它线程，同时CPU也会监视睡眠的时间，一旦睡眠时间到了会继续执行代码，如果时间未到就要醒 需要使用interrupt()来随时唤醒，睡眠过程中仍然保留着锁，有锁只要睡眠时间到就能立刻执行


public static void main(String[] args) throws InterruptedException{
    Thread thread0 = new Thread(() -> {
            try {
                //调用interrupt()方法，会使得sleep()方法抛出InterruptedException异常
                System.out.println(Thread.currentThread().getName() + "/睡眠"+new Date());
                Thread.sleep(10000);
            } catch (InterruptedException e) {
                System.out.println(Thread.currentThread().getName() + "/异常/唤醒"+new Date());
            }
        });
        thread0.start();

        // 这里睡眠只是为了保证先让上面的那个线程先执行
        Thread.sleep(2000);

        new Thread(() -> {
            System.out.println(Thread.currentThread().getName() + "/唤醒"+new Date());
            // 无需获取锁就可以调用interrupt
            thread0.interrupt();
        }).start();
}
//out
Thread-0/睡眠Tue Jul 06 14:27:07 CST 2021
Thread-1/唤醒Tue Jul 06 14:27:09 CST 2021
Thread-0/异常/唤醒Tue Jul 06 14:27:09 CST 2021

interrupt（）方法其实作用是中断此线程（此线程不一定是当前线程，而是指调用该方法的Thread实例所代表的线程），但实际上只是给线程设置一个中断标志，线程仍会继续运行。
interrupted()判断当前是否被中断

new Thread(()->{
            try {
                Thread.sleep(1000);
                Thread.currentThread().interrupt();
                System.out.println("当前线程是否中断_02：" + Thread.interrupted());
                System.out.println("当前线程是否中断_03：" + Thread.interrupted());
            }catch (InterruptedException e){

            }
        }).start();

        System.out.println("当前线程是否中断_01："+Thread.interrupted());
        Thread.sleep(2000);
    //out
当前线程是否中断_01：false
当前线程是否中断_02：true
当前线程是否中断_03：false

wait、notify

wait、notify和notifyAll方法是Object类的final native方法，所以这些方法不能被子类重写，因此在程序中可以通过this去调用，像this.wait()…

wait(): 导致线程进入等待阻塞状态，会一直等待直到它被其他线程通过notify()或者notifyAll()唤醒，这个方法只能在同步方法中调用

notify(): 该方法只能在同步方法或同步块内部调用， 随机选择一个(注意：只会通知一个)在该对象上调用wait方法的线程，解除其阻塞状态
notifyAll(): 唤醒所有的wait对象

class TempdemoApplicationTests {

public static void main(String[] args) throws Exception {
        TempdemoApplicationTests waitNotifyTest = new TempdemoApplicationTests();
        new Thread(() -> {
            try {
                waitNotifyTest.TempWait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }).start();
        
        new Thread(() -> {
            try {
                waitNotifyTest.TempWait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }).start();
        
		//睡眠1秒先执行wait()
        new Thread(() -> {
            try {
                System.out.println(new Date() + "\t" + Thread.currentThread().getName()+"睡眠1秒");
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
			//随机唤醒一个线程
            waitNotifyTest.TempNotify();
        }).start();
    }

    private synchronized void TempWait() throws InterruptedException {
        System.out.println(new Date() + "\t" + Thread.currentThread().getName() + "等待...");
        this.wait();
        System.out.println(new Date() + "\t" + Thread.currentThread().getName() + "结束...");
    }

    private synchronized void TempNotify() {
    	//如果当前线程不是锁的持有者，该方法抛出一个IllegalMonitorStateException异常
        this.notify();
        System.out.println(new Date() + "\t" + Thread.currentThread().getName() + "完成...");
    }
}
//out
Mon Jun 28 23:50:11 GMT+08:00 2021	Thread-0等待...
Mon Jun 28 23:50:11 GMT+08:00 2021	Thread-2睡眠1秒
Mon Jun 28 23:50:11 GMT+08:00 2021	Thread-1等待...
Mon Jun 28 23:50:12 GMT+08:00 2021	Thread-2完成...
Mon Jun 28 23:50:12 GMT+08:00 2021	Thread-0结束...


//这个地方有个注意的地方就是 wait会释放锁但是sleep不会
public static void main(String[] args) throws Exception {
        Object lock = new Object();

        new Thread(() -> {
            synchronized (lock) {
                for (int i = 0; i < 5; i++) {
                    System.out.println(new Date() + "\t" + Thread.currentThread().getName()+i);
                    try {
                        Thread.sleep(1000);
                        //lock.wait(1000);
                    } catch (InterruptedException e) {
                    }
                }
            }
        },"Thread_0").start();
		//不会释放锁 sleep使用interrupt()来唤醒，wait需要notify或者notifyAll来通知
		//让上面的先拿到锁
        Thread.sleep(1000);

        new Thread(() -> {
            synchronized (lock) {
                for (int i = 0; i < 5; i++) {
                    System.out.println(new Date() + "\t" + Thread.currentThread().getName()+i);
                }
            }
        },"Thread_1").start();

    }
   //out
Mon Jun 28 23:53:38 GMT+08:00 2021	Thread_0 0
Mon Jun 28 23:53:40 GMT+08:00 2021	Thread_0 1
Mon Jun 28 23:53:41 GMT+08:00 2021	Thread_0 2
Mon Jun 28 23:53:42 GMT+08:00 2021	Thread_0 3
Mon Jun 28 23:53:43 GMT+08:00 2021	Thread_0 4
Mon Jun 28 23:53:44 GMT+08:00 2021	Thread_1 0
Mon Jun 28 23:53:44 GMT+08:00 2021	Thread_1 1
Mon Jun 28 23:53:44 GMT+08:00 2021	Thread_1 2
Mon Jun 28 23:53:44 GMT+08:00 2021	Thread_1 3
Mon Jun 28 23:53:44 GMT+08:00 2021	Thread_1 4

join

join本身是一个线程安全的方法，它的作用是将一个线程加入另一个线程当中，线程加入后会优先执行完当前加入的线程后再执行线程后的内容

    public static void main(String[] args) {
            new Thread(new ParentDemoRunable()).start();
    }


class ParentDemoRunable implements Runnable {
    @Override
    public void run() {
        // 线程处于new状态
        Thread childThread = new Thread(new DemoRunable());
        // 线程处于runnable就绪状态
        childThread.start();
        try {
            // 当调用join时，当前线程会等加入的线程执行完毕后再继续运行
            // 将某个线程加入到当前线程
            childThread.join();
            System.out.println("子线程执行完毕");
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        for (int i = 0; i < 5; i++) {
            System.out.println(new Date() + "\t" + Thread.currentThread().getName() + "父线程+++");
        }
    }
}
class DemoRunable implements Runnable {
    @Override
    public void run() {
        for (int i = 0; i < 5; i++) {
            try { Thread.sleep(1000); } catch (InterruptedException e) {}
            System.out.println(new Date() + "\t" + Thread.currentThread().getName() + "子线程+++");
        }
    }
}

//out
Tue Jun 29 19:45:09 CST 2021	Thread-1子线程+++
Tue Jun 29 19:45:10 CST 2021	Thread-1子线程+++
Tue Jun 29 19:45:11 CST 2021	Thread-1子线程+++
Tue Jun 29 19:45:12 CST 2021	Thread-1子线程+++
Tue Jun 29 19:45:13 CST 2021	Thread-1子线程+++
子线程执行完毕
Tue Jun 29 19:45:13 CST 2021	Thread-0父线程+++
Tue Jun 29 19:45:13 CST 2021	Thread-0父线程+++
Tue Jun 29 19:45:13 CST 2021	Thread-0父线程+++
Tue Jun 29 19:45:13 CST 2021	Thread-0父线程+++
Tue Jun 29 19:45:13 CST 2021	Thread-0父线程+++

join()方法使用后会调用join(0)方法 join本身执行并没有加锁，join(0)会加锁，join(0)会循环判断线程是否处于活动状态，如果加入的线程执行完毕则结束掉join()继续回到父线程体中执行后面的程序

在这里插入图片描述

yield

此方法很少被使用到,它的作用是交出CPU的执行时间，不会释放锁，让线程进入就绪状态，等待重新获取CPU执行时间
就是说使当前线程从执行状态（运行状态）变为可执行态（就绪状态），但是我们知道cpu会从众多的就绪状态中的线程中分配执行某个线程，也就是说刚刚的那个线程还是有可能会被再次执行到的，并不是说一定会执行其他线程而该线程在下一次中不会执行到了

 public static void main(String[] args) {
       new Thread(new Runnable() {
            int sum = 0;
            @Override
            public void run() {
                long beginTime=System.currentTimeMillis();
                for (int i = 0; i < 99999; i++) {
                    sum += 1;
                    //Thread.yield();
                }
                long endTime=System.currentTimeMillis();
                System.out.println("用时："+ (endTime - beginTime) + " 毫秒！");
            }
        }).start();
        new Thread(new Runnable() {
            int sum = 0;
            @Override
            public void run() {
                long beginTime=System.currentTimeMillis();
                for (int i = 0; i < 99999; i++) {
                    sum += 1;
                    Thread.yield();
                }
                long endTime=System.currentTimeMillis();
                System.out.println("用时："+ (endTime - beginTime) + " 毫秒！");
            }
        }).start();


    }
    //out
用时：1 毫秒！
用时：53 毫秒！

setDaemon

主线程和用户线程的生命周期本身是各自独立的，setDaemon可以将用户线程设置为守护线程

public static void main(String[] args) throws Exception{
        Thread thread = new Thread(()->{
            try{
            for (int i = 0; i <10 ; i++) {
                Thread.sleep(1000);
                System.out.println(Thread.currentThread().getName()+"\t"+i);
            }
            }catch (Exception e){
                e.printStackTrace();
            }
        },"Thread_子线程");

        thread.setDaemon(true);
        thread.start();

        for (int i = 0; i <5 ; i++) {
            Thread.sleep(1000);
            System.out.println(Thread.currentThread().getName()+"\t"+i);
        }
        System.out.println("结束");
    }
    //out
    Thread_子线程	0
	main	0
	main	1
	Thread_子线程	1
	main	2
	Thread_子线程	2
	main	3
	Thread_子线程	3
	main	4
	Thread_子线程	4
	结束

线程池

在我们实际工作显式的去创建线程当并发很大时可能会使得内存耗尽，因为每个线程都需要被分配内存空间，线程是稀缺资源，如果无限制的创建不仅会消耗系统资源，还会降低系统的稳定性，实际开发中某些线程创建频繁的情况下一般使用线程池来控制线程的最大个数来合理的重复的利用线程，使用线程池可以进行统一分配，调优和监控

  1. 使用线程池可以降低资源的消耗，通过重复利用已创建的线程降低线程创建和销毁造成的消耗
  2. 提高响应速度，当任务到达时，任务可以不需要等到线程池创建就能立即执行
  3. 提高线程的可管理性。

ThreadPoolExecutor

ThreadPoolExecutor类是线程池中最核心的一个类，所有线程池创建都离不开这个类的使用，它的类中提供了四个构造方法

public class ThreadPoolExecutor extends AbstractExecutorService {
    .....
    public ThreadPoolExecutor(int corePoolSize,int maximumPoolSize
    		,long keepAliveTime,TimeUnit unit,
            BlockingQueue<Runnable> workQueue);
 
    public ThreadPoolExecutor(int corePoolSize,int maximumPoolSize
    		,long keepAliveTime,TimeUnit unit,
            BlockingQueue<Runnable> workQueue,ThreadFactory threadFactory);
 
    public ThreadPoolExecutor(int corePoolSize,int maximumPoolSize
    		,long keepAliveTime,TimeUnit unit,
            BlockingQueue<Runnable> workQueue,RejectedExecutionHandler handler);
 
    public ThreadPoolExecutor(int corePoolSize,int maximumPoolSize
    		,long keepAliveTime,TimeUnit unit,
        	BlockingQueue<Runnable> workQueue
        	,ThreadFactory threadFactory,RejectedExecutionHandler handler);
    ...
}
  1. corePoolSize：核心池的大小，这个参数跟线程池的实现原理有非常大的关系。在创建了线程池后，默认情况下，线程池中并没有任何线程，而是等待有任务到来才创建线程去执行任务，默认情况下，在创建了线程池后，线程池中的线程数为0，当有任务来之后，就会创建一个线程去执行任务，当线程池中的线程数目达到corePoolSize后，就会把到达的任务放到缓存队列当中
  2. maximumPoolSize：线程池最大线程数，它表示在线程池中最多能创建多少个线程
  3. keepAliveTime：表示线程没有任务执行时最多保持多久时间会终止。默认情况下，只有当线程池中的线程数大于corePoolSize时，keepAliveTime才会起作用，直到线程池中的线程数不大于corePoolSize，就是说当线程池中的线程数大于corePoolSize时，如果一个线程空闲的时间达到keepAliveTime，则会终止，直到线程池中的线程数不超过corePoolSize
  4. unit：参数keepAliveTime的时间单位，有7种取值，在TimeUnit类中有7种静态属性
  5. workQueue：一个阻塞队列，用来存储等待执行的任务，这个参数的选择会对线程池的运行过程产生重大影响，一般来说，这里的阻塞队列有以下几种选择：
    ArrayBlockingQueue
    LinkedBlockingQueue 常用
    SynchronousQueue 常用
  6. threadFactory：线程工厂，主要用来创建线程
  7. handler：表示当拒绝处理任务时的策略，有以下四种取值：
    ThreadPoolExecutor.AbortPolicy:丢弃任务并抛出RejectedExecutionException异常。
    ThreadPoolExecutor.DiscardPolicy：也是丢弃任务，但是不抛出异常。
    ThreadPoolExecutor.DiscardOldestPolicy：丢弃队列最前面的任务，然后重新尝试执行任务（重复此过程）
    ThreadPoolExecutor.CallerRunsPolicy：由调用线程处理该任务

ThreadPoolExecutor继承了AbstractExecutorService ，并且实现了几个操作线程池重要的方法

  1. execute():该方法实际上是Executor中声明的方法，在ThreadPoolExecutor进行了具体的实现，这个方法是ThreadPoolExecutor的核心方法，通过这个方法可以向线程池提交一个任务，交由线程池去执行

  2. submit()：该方法是在ExecutorService中声明的方法，在AbstractExecutorService就已经有了具体的实现，在ThreadPoolExecutor中并没有对其进行重写，这个方法也是用来向线程池提交任务的，但是它和execute()方法不同，它能够返回任务执行的结果，去看submit()方法的实现，会发现它实际上还是调用的execute()方法

  3. shutdown()/shutdownNow() :关闭线程池

四种创建线程池的方式

在这里插入图片描述

newCachedThreadPool

创建一个可缓存线程池，如果线程池长度超过处理需要，可灵活回收空闲线程，若无可回收，则新建线程，缓存线程池创建的个数是去不确定的，根据每个线程的总执行时间确定的，当一个线程执行完后会有60秒的存活时间，如果有新的任务需要执行就使用刚才执行完空闲的线程执行，如果没有空闲的线程则新启动一个线程，最多启动Integer.MAX_VALUE个线程

public static void main(String[] args) {
        ExecutorService executorService = Executors.newCachedThreadPool();
    
        for (int i = 0; i < 10; i++) {
            int tempI = i;
            executorService.execute(new Runnable() {
                @Override
                public void run() {
		System.out.println(Thread.currentThread().getName()+"\t"+"i="+tempI );
                }
            });
        }
       
        executorService.shutdown();
}
//out
pool-1-thread-2	i=1
pool-1-thread-4	i=3
pool-1-thread-3	i=2
pool-1-thread-1	i=0
pool-1-thread-6	i=5
pool-1-thread-5	i=4
pool-1-thread-7	i=6
pool-1-thread-8	i=7
pool-1-thread-10	i=9
pool-1-thread-9	i=8

newFixedThreadPool

创建一个定长线程池，可控制线程最大并发数，超出的线程会在队列中等待。

public class ThreadPoolTest {
    public static void main(String[] args) {
        // 固定线程池，线程池中的个数是固定的值
        ExecutorService executorService = Executors.newFixedThreadPool(5);
        for (int i = 0; i < 10; i++) {
            Thread thread = new Thread(() -> {
                System.out.println(Thread.currentThread().getName());
            });
            executorService.execute(thread);
        }
        executorService.shutdown();
    }
}
//out
pool-1-thread-1
pool-1-thread-5
pool-1-thread-1
pool-1-thread-4
pool-1-thread-3
pool-1-thread-2
pool-1-thread-3
pool-1-thread-4
pool-1-thread-1
pool-1-thread-5

newSingleThreadExecutor

创建一个定长线程池，支持定时及周期性任务执行,使用schedule向线程池提交任务

public static void main(String[] args) {  
       ScheduledExecutorService scheduledThreadPool = Executors.newScheduledThreadPool(5);
            for (int i = 0; i < 5; i++) {
                ScheduledFuture<String> schedule = scheduledThreadPool.schedule(new Callable<String>() {
                    public String call() throws Exception {
                        System.out.println(Thread.currentThread().getName());
                        return "ScheduledFuture";
                    }
                }, 1, TimeUnit.SECONDS);
                System.out.println(schedule.get() + "\t" +new Date());
            }

        scheduledThreadPool.shutdown();
  
    }
    //out
pool-1-thread-1
ScheduledFuture	Mon Jul 05 14:35:22 CST 2021
pool-1-thread-1
ScheduledFuture	Mon Jul 05 14:35:23 CST 2021
pool-1-thread-2
ScheduledFuture	Mon Jul 05 14:35:24 CST 2021
pool-1-thread-1
ScheduledFuture	Mon Jul 05 14:35:25 CST 2021
pool-1-thread-1
ScheduledFuture	Mon Jul 05 14:35:26 CST 2021

newSingleThreadExecutor

创建一个单线程化的线程池，它只会用唯一的工作线程来执行任务,按顺序来执行线程任务 但是不同于单线程，这个线程池只是只能存在一个线程，这个线程死后另外一个线程会补上。

 public static void main(String[] args) throws Exception{
        ExecutorService simpleExecutor = Executors.newSingleThreadExecutor();
        for (int i = 0; i < 5; i++) {
            int tempI = i;
            simpleExecutor.execute(new Runnable() {
                public void run() {
                    System.out.println(Thread.currentThread().getName()+"\t"+"i="+tempI);
                }
            });
        }
        simpleExecutor.shutdown();
 }
 //out
 pool-1-thread-1	i=0
pool-1-thread-1	i=1
pool-1-thread-1	i=2
pool-1-thread-1	i=3
pool-1-thread-1	i=4

锁

synchronized 对象锁/类锁

public class ObjectClassLock {
    public static void main(String[] args) {
        TempText tempText  = new TempText ();

        new Thread(new Runnable() {
            @Override
            public void run() {
                tempText.test();
            }
        }, "Thread_01").start();


        new Thread(new Runnable() {
            @Override
            public void run() {
                tempText.test2();
            }
        }, "Thread_02").start();
    }
}

class TempText {
    // 锁的是testService这个对象
    public synchronized void test() {
        for(int i = 0; i < 2; i++) {
        System.out.println(new Date() + "\t" + Thread.currentThread().getName());
        try {
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        }
        System.out.println((new Date() + "\t" + Thread.currentThread().getName() + "\t 结束"));
    }

    // 静态是锁的TempText 这个类(TempText .class)
    // 对象锁和类锁不是同一个锁，所以两个方法不会互斥
    public synchronized static void test2() {

        for(int i = 0; i < 2; i++) {
        System.out.println(new Date() + "\t" + Thread.currentThread().getName());
        try {
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        }
        
        System.out.println((new Date() + "\t" + Thread.currentThread().getName() + "\t 结束"));
    }
}
//out
Mon Jul 05 15:05:16 CST 2021	Thread_02
Mon Jul 05 15:05:16 CST 2021	Thread_01
Mon Jul 05 15:05:18 CST 2021	Thread_01
Mon Jul 05 15:05:18 CST 2021	Thread_02
Mon Jul 05 15:05:20 CST 2021	Thread_01	 结束
Mon Jul 05 15:05:20 CST 2021	Thread_02	 结束

--都替换为静态方法后
Mon Jul 05 15:05:51 CST 2021	Thread_01
Mon Jul 05 15:05:53 CST 2021	Thread_01
Mon Jul 05 15:05:55 CST 2021	Thread_01	 结束
Mon Jul 05 15:05:55 CST 2021	Thread_02
Mon Jul 05 15:05:57 CST 2021	Thread_02
Mon Jul 05 15:05:59 CST 2021	Thread_02	 结束

Lock锁

Lock需要手动加锁，释放锁也需要手动释放，释放锁最好(必须)放到finally代码块中释放
同一个锁可以加锁多次，也就是调用多次lock()，相应的加N次锁也必须解N次锁，使用unlock()，一般情况下都是加一次锁和解一次锁

加锁lock()与释放锁unlock()

public static void main(String[] args) throws Exception{

        Lock lock = new ReentrantLock();

        Runnable runnable = () -> {
            System.out.println(new Date() + "\t" + Thread.currentThread().getName());
            lock.lock();

            try {
                for(int i = 0; i < 4; i++) {
                    System.out.println(new Date() + "\t" + Thread.currentThread().getName() +  "\ti=" + i);

                }
            } catch (Exception e) {
                e.printStackTrace();
            } finally {
                lock.unlock();
            }
        };
        Runnable runnable2 = () -> {
            System.out.println(new Date() + "\t" + Thread.currentThread().getName());
            lock.lock();

            try {
                for(int i = 0; i < 4; i++) {
                    System.out.println(new Date() + "\t" + Thread.currentThread().getName() +  "\ti=" + i);

                }
            } catch (Exception e) {
                e.printStackTrace();
            } finally {
                lock.unlock();
            }
        };

        new Thread(runnable, "Thread-A").start();
        new Thread(runnable2, "Thread-B").start();
    }
    //out
Mon Jul 05 17:29:56 CST 2021	Thread-B
Mon Jul 05 17:29:56 CST 2021	Thread-A
Mon Jul 05 17:29:56 CST 2021	Thread-B	i=0
Mon Jul 05 17:29:56 CST 2021	Thread-B	i=1
Mon Jul 05 17:29:56 CST 2021	Thread-B	i=2
Mon Jul 05 17:29:56 CST 2021	Thread-B	i=3
Mon Jul 05 17:29:56 CST 2021	Thread-A	i=0
Mon Jul 05 17:29:56 CST 2021	Thread-A	i=1
Mon Jul 05 17:29:56 CST 2021	Thread-A	i=2
Mon Jul 05 17:29:56 CST 2021	Thread-A	i=3

锁被线程B拿到后 先执行完释放锁后才被其他线程拿到锁

java劝退师_mysql删库师
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
线程，多线程，线程池，线程上下文，锁一键启动
weixin_46577306的博客
05-21 375
多线程并发知识库 JAVA线程实现/创建的四种方式 1.继承Thread类 Thread类本质上是实现了Runnable接口的一个实例，代表一个线程的实例。启动线程的唯一方法就是通过Thread类的start()实例方法。start()方法是一个native方法，它将启动一个新线程，并执行run()方法。 public class MyThread extends Thread { public void run() { System.out.prin...
SingleThreadExecutor 用和不用的区别
Aichuiniu666的博客
08-23 406
SingleThreadExecutor 存在的意义
Java线程池从使用到阅读源码(3/10)
weixin_34378045的博客
03-18 187
我们一般不会选择直接使用线程类Thread进行多线程编程，而是使用更方便的线程池来进行任务的调度和管理。线程池就像共享单车，我们只要在我们有需要的时候去获取就可以了。甚至可以说线程池更棒，我们只需要把任务提交给它，它就会在合适的时候运行了。但是如果直接使用Thread类，我们就需要在每次执行任务时自己创建、运行、等待线程了，而且很难对线程进行整体的管理，这可不是一件轻松的事情。既然我们已经有了线程...
Executors.newSingleThreadExecutor的一些坑
热门推荐
zhuyucheng123的专栏
06-02 3万+
还是直接上源码吧 public static ExecutorService newSingleThreadExecutor() { return new FinalizableDelegatedExecutorService (new ThreadPoolExecutor(1, 1,
curl线程池多线程调用
09-20
文件"CurlHighSpeed"可能包含了实现上述功能的示例代码或详细教程，可以帮助我们深入理解和实践`curl`的多线程线程池技术。通过学习和应用这些知识，我们可以优化网络请求的性能，提升整体系统的响应速度和用户体验...
Java多线程+线程池.docx
03-31
Java 多线程和线程池 Java 多线程是指在 Java 编程语言中，一个线程的动态执行过程。这个过程包括线程的创建、执行和销毁三个阶段。在 Java 中，创建线程有多种方式，包括通过实现 Runnable 接口、继承 Thread 类...
多线程与线程池技术详解
06-12
在Java编程领域，多线程和线程池技术是核心且关键的概念，它们在现代的高性能、高并发应用中扮演着重要角色。多线程允许应用程序同时执行多个任务，而线程池则是一种管理和控制线程的有效手段，有助于提高系统的效率...
多线程与线程池技术详解（图书配套）
07-01
多线程与线程池是Java编程中至关重要的概念，特别是在处理高并发场景时，它们的作用尤为突出。本文将深入探讨这两个主题，并结合标签中的"排它锁"、"重入锁"、"共享锁"等概念进行讲解。 首先，线程是操作系统分配...
java多线程和锁，用于学习参考
09-09
Java多线程与锁是Java并发编程中的核心概念，它们在构建高效、可扩展的并发应用程序中起着至关重要的作用。下面将详细讲解这两个主题。 首先，Java中的多线程是指程序执行时可以同时进行多个任务。这得益于操作系统...
Java 并发
mmonkeyer的博客
10-18 536
并发 Table of Contents 1 什么是并发问题。 2 java中synchronized的用法 3 Java中的锁与排队上厕所。 4 何时释放锁？ 5 Lock的使用 6 利用管道进行线程间通信 7 阻塞队列 8 使用Executors、Executor、ExecutorService、Thread...
从线程池到synchronized关键字详解
weixin_34004750的博客
01-20 166
线程池 BlockingQueue synchronized volatile 前段时间看了一篇关于"一名3年工作经验的程序员应该具备的技能"文章，倍受打击。很多熟悉而又陌生的知识让我怀疑自己是一个假的程序员。本章从线程池，阻塞队列，synchronized 和 volatile关键字，wait，notify方法实现线程之间的通讯，死锁，...
多线程·锁池与等待池(jdk1.8)；在乐观锁下，真的有必要关心CAS中的ABA问题吗？？？
以镒称铢的博客
04-01 473
目录 进程、线程、协程 线程的目标 线程的切换 线程的管理 乐观锁策略 本来不想聊关于线程的话题，主要原因在于自己对计算机原理相关的知识了解太浅，怕耽搁大家。 可是网络上的文章太多东拼西凑、莫名其妙，最近在读一些博文的时候被气到了，于是勉强阐述一些个人在线程方面的理解。 进程、线程、协程 当说起线程的时候，总是避不开进程和协程，较官方些的定义如下： 进程：操作系统分配资源...
多线程+线程池，锁
qq_42728113的博客
03-25 998
创建线程的方法： 继承Thread 类 Thread 类本质上是实现了Runnable 接口的一个实例，代表一个线程的实例。启动线程的唯一方法就是通过Thread 类的start()实例方法。start()方法是一个native 方法，它将启动一个新线程，并执行run()方法。 实现Runnable 接口 如果自己的类已经extends 另一个类，就无法直接extends Thread，此时，可以实现一个Runnable 接口； 启动线程需要实例化一个Thread，并传入实现runnable的实例
关于Executors.newSingleThreadExecutor()的作用！-这个代码有问题，误导了大家抱歉
yao752915708的专栏
06-26 3万+
Executors.newSingleThreadExecutor()返回一个线程池（这个线程池只有一个线程） ,这个线程池可以在线程死后（或发生异常时）重新启动一个线程来替代原来的线程继续执行下去！ import java.util.Random; import java.util.concurrent.ExecutorService; import java.util.concur...
java并发网_Java并发newSingleThreadExecutor()方法
weixin_36068199的博客
02-20 821
可以通过调用Executors类的static newSingleThreadExecutor()方法获得单个线程池。语法ExecutorService executor = Executors.newSingleThreadExecutor();newSingleThreadExecutor()方法创建一次执行单个任务的执行程序。示例以下TestThread程序显示了基于线程的环境中newSin...
newSingleThreadExecutor的运用
iuie_sl的博客
06-16 1万+
运用场景： 在一个api中，程序的最后要调用一个存储过程，但是存储过程调用完需要花费很多的时间，程序并并不关心最后调的存储过程的执行结果。所以想到最后重新开一个线程来调用储存过程 ，主线程直接返回结果。但是由于储存过程执行的时间很长，所以用户同时访问的时候很容易出现几个调用存储过程的线程在后台同时运行，如果他们操作了同一张表的同一条数据， 就容易导致死锁。所以我们希望调用存储过程的线程一次只有一个...
单线程化线程池newSingleThreadExecutor的关闭
forever_together的博客
04-21 2587
现在工作中使用线程池的话，基本上都使用jdk自带的Executors类，我在一次开发当中使用到了单线程化线程池(newSingleThreadExecutor)， 单线程化线程池(newSingleThreadExecutor)的优点，串行执行所有任务。如果这个唯一的线程因为异常结束，那么会有一个新的线程来替代它。 此线程池保证所有任务的执行顺序按照任务的提交顺序执行。 但是我在开发中是这样子做的，有20个任务，我代码像下面这样子写的，有点性能问题，该任务执行完毕后，系统多了20个无用的线程池。
java线程池之newSingleThreadExecutor
qq_40308101的博客
03-26 3755
1、特点 单线程化的线程池、保证所有任务按照指定顺序执行 2、创建实例 ExecutorService executorService = Executors.newSingleThreadExecutor(); 3、运行举例 ExecutorService executorService = Executors.newSingleThreadExecutor(); ...
java 多线程 线程池推荐书籍
最新发布
10-20
1.《Java并发编程实战》：这本书是Java多线程编程的经典之作，详细介绍了Java并发编程的基础知识、并发编程模型、线程安全性、锁、线程池等内容。 2.《Java并发编程的艺术》：这本书是一本非常实用的Java多线程编程...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值