Java多线程

最新推荐文章于 2024-12-01 23:53:39 发布
原创 最新推荐文章于 2024-12-01 23:53:39 发布 · 1k 阅读 · 4 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#java #多线程 #编程语言

多线程

1.线程与进程

1.1线程与进程

进程

  • 是指一个内存中运行的应用程序，每个进程都有一个独立的内存空间

线程

  • 是进程中的一个执行路径，共享一个内存空间，线程之间可以自由切换，并发执行，一个进程最少有一个线程
  • 线程实际上是在进程基础之上的进一步划分，一个进程启动之后，里面的若干执行路径又可以划分成若干个线程

1.2线程调度

分时调度

  • 所有线程轮流使用CPU的使用权，平均分配每个线程占用CPU的时间。

抢占式调度

  • 优先让优先级高的线程使用CPU，如果线程的优先级相同，那么会随机选择一个(线程随机性)，Java使用的为抢占式调度。
  • CPU使用抢占式调度模式在多个线程间进行着高速的切换。对于CPU的一个核心而言，某个时刻，只能执行一个线程，而CPU的在多个线程间切换速度相对我们的感觉更快，看上去就像是在同一时刻运行。其实，多线程并不能提高程序的运行速度，但能提高程序运行效率，让CPU的使用率更高。

2.同步与异步&并发与执行

2.1同步与异步

同步：排队执行，效率低但是安全
异步：同时执行，效率高但是不安全

2.2并发与并行

并发：指两个或多个事件在同一个时间段发生
并行：指两个或多个事件在同一个时刻发生

3.继承Thread

线程代码

public class MyThread extends Thread{
	//run方法就是线程要执行的任务方法
	public void run(){
		//这里的代码就是一条新的执行路径
		//这个执行路径的触发方式不是调用run方法，而是通过thread对象的start()来启动任务
		for(int i=0;i<10;i++){
			System.out.println("线程1"+i);
		}
	}
}

主函数

public static void main(String[] args){
	MyThread m = MyThread();
	m.start();
	for(int i=0;i<10;i++){
		System.out.println("线程2"+i);
	}
}

因为java用的是抢占式分配，每次运行结果都会不同，并发执行

线程运行图示
每个线程都拥有自己的栈空间，共用一份堆内存。

匿名内部类创建线程

public static void main(String[] args) {
	new Thread(){
		@Override
		public void run(){
			for(int i=0;i<10;i++){
				System.out.println("线程 1 "+i);
			}
		}
	}.start();
	for(int i=0;i<10;i++){
		System.out.println("线程 2 "+i);
	}
}

4.实现Runnable

实现Runnable代码

//用于给线程进行执行的任务
public class MyRunnable implements Runnable{
	@Override
	public void run(){
		//线程的任务
		for(int i=0;i<10;i++){
			System.out.println("线程1 "+i);
		}
	}
}

主函数

public static void main(String[] args) {
	//实现Runnable
	//1.  创建一个任务对象
	MyRunnable r = new MyRunnable();
	//2.  创建一个线程，并为其分配一个任务
    Thread t = new Thread(r);
    //3.  执行这个线程
    t.start();
    for (int i = 0; i < 10; i++) {
    	System.out.println("线程2 " + i);
    }
}

实现Runnable与继承Thread相比有如下优势：

  1. 通过创建任务，然后给线程分配的方式来实现的多线程，更适合多个线程同时执行相同任务的情况。
  2. 可以避免单继承所带来的局限性。
  3. 任务与线程本身是分离的，提高了程序的健壮性。
  4. 后续学习的线程池技术，接收Runnable类型的任务，不接受Thread类型的线程。

5.Thread类

构造方法

构造器描述
Thread()分配新的 Thread对象
Thread​(Runnable target)分配新的 Thread对象
Thread​(Runnable target, String name)分配新的 Thread对象
Thread​(String name)分配新的 Thread对象

常用方法

变量和类型方法描述
longgetId()返回此Thread的标识符。
StringgetName()返回此线程的名称。
intgetPriority()返回此线程的优先级。
voidsetName​(String name)将此线程的名称更改为等于参数 name 。
voidsetPriority​(int newPriority)更改此线程的优先级。
voidstart()导致此线程开始执行; Java虚拟机调用此线程的run方法。
static voidsleep​(long millis)导致当前正在执行的线程休眠（暂时停止执行）指定的毫秒数，具体取决于系统计时器和调度程序的精度和准确性。 (参数为毫秒)
static voidsleep​(long millis, int nanos)导致当前正在执行的线程休眠（暂时停止执行）指定的毫秒数加上指定的纳秒数，具体取决于系统定时器和调度程序的精度和准确性。（参数为毫秒和纳秒）
voidstop()已过时，这种方法本质上是不安全的。
voidsetDaemon​(boolean on)将此线程标记为 daemon(守护)线程或用户线程。守护线程依附于用户线程，用户线程全部死亡后，守护线程自动死亡

补充一下线程优先级的字段

变量和类型字段描述
static intMAX_PRIORITY线程可以拥有的最大优先级。
static intMIN_PRIORITY线程可以拥有的最低优先级。
static intNORM_PRIORITY分配给线程的默认优先级。

关于如何停止线程：

之前所使用的stop()方法会导致线程未释放资源而直接停止，不安全，因此弃用。
现在使用的停止变量的方式多为规划一个变量，当这个变量改变时停止线程，并停止前释放资源。

6.设置和获取线程名称

public static void main(String[] args) {
	new Thread(new MyRunnable(),"锄禾日当午").start();
	new Thread(new MyRunnable()).start();
	new Thread(new MyRunnable()).start();
}
static class MyRunnable implements Runnable {
	@Override
	public void run() {
    System.out.println(Thread.currentThread().getName());
    //currentThread()方法可以用来获取当前的线程
    }
}

不设置线程名称默认是：Thread-0，Thread-1…

7.线程休眠sleep

public static void main(String[] args) throws InterruptedException {
	for (int i=0;i<10;i++){
        System.out.println(i);
        Thread.sleep(1000);
    }
}

改代码会每过一秒打印。

8.线程的中断

一个线程是一个独立的执行路径，它是否应该结束，应该由其自身决定。

下面是线程中断的示例代码

	public static void main(String[] args){
        Thread t1 = new Thread(new MyRunnable());
        t1.start();
        //main线程循环4次，在main结束后中断t1线程
        for (int i=1;i<5;i++){
            System.out.println(Thread.currentThread().getName()+":"+i);
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        //给t1添加中断标记，使其进入catch块
        t1.interrupt();
    }
    static class MyRunnable implements Runnable {

        @Override
        public void run() {
            for (int i=1;i<10;i++){
                System.out.println(Thread.currentThread().getName()+":"+i);
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    //e.printStackTrace();
                    System.out.println("检测到中断标记，线程死亡");
                    return;
                }
            }
        }
    }

运行截图
在这里插入图片描述
线程的中断绝对不应使用stop()方法

9.守护线程

  • 线程：分为守护线程和用户线程
  • 用户线程：当一个进程不包含任何存活的用户线程时，进程结束
  • 守护线程：守护用户线程的，当最后一个用户线程结束时，所有守护线程自动死亡。

下面是演示代码

	public static void main(String[] args){
        Thread t1 = new Thread(new MyRunnable());
        //设置t1为守护线程，守护线程要在线程开始前设置
        t1.setDaemon(true);
        t1.start();
        //main线程循环4次
        for (int i=1;i<5;i++){
            System.out.println(Thread.currentThread().getName()+":"+i);
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
    static class MyRunnable implements Runnable {

        @Override
        public void run() {
            for (int i=1;i<10;i++){
                System.out.println(Thread.currentThread().getName()+":"+i);
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();

                }
            }
        }
    }

在这里插入图片描述
因为main方法结束需要时间，所以在main输出4之后t1线程在main结束的时间内输出了4和5，之后main结束，守护线程t1也随着结束。

10.线程安全问题

10.1线程不安全问题

线程不安全代码示例（卖票案例）

    //线程不安全
    public static void main(String[] args){
        Runnable run = new MyRunnable();
        new Thread(run).start();
        new Thread(run).start();
        new Thread(run).start();

    }
    static class MyRunnable implements Runnable {
        //票数
        private int count = 10;
        @Override
        public void run() {

            while(count>0){
                //卖票
                
                System.out.println("准备出票");

                //休眠一秒，增大线程抢占的几率
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                count--;
                System.out.println("出票完成，剩余票数："+count);
            }

        }
    }

代码看起来没有问题，下面是最后的运行截图
在这里插入图片描述
我们发现，在代码中的while规定了count要大于0，但结果出现了-1和-2这种不合理的结果。

这是因为在进程中，假设有三个线程A,B,C。线程A先进入，此时count为1，当A在休眠过程中，被B强占时间片，但是因为A在休眠，count仍然是1，线程B可以进入循环，然而在A休眠结束，准备count–并且B在休眠时，C进入了循环，这就导致了结果产生0，-1还有-2，产生了线程不安全问题。

10.1.1线程不安全问题解决1：同步代码块

可以简单认为：被同步代码块所括住的内容需要排队执行

格式：synchronized(锁对象){ }

代码示例：

    public static void main(String[] args){
        Runnable run = new MyRunnable();
        new Thread(run).start();
        new Thread(run).start();
        new Thread(run).start();

    }
    static class MyRunnable implements Runnable {
        private Object o = new Object();
        //票数
        private int count = 10;
        @Override
        public void run() {
            while(true) {
                synchronized(o) {
                    if (count > 0) {

                        //卖票

                        System.out.println("准备出票");

                        //休眠一秒，增大线程抢占的几率
                        try {
                            Thread.sleep(1000);
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                        count--;
                        System.out.println("出票完成" + Thread.currentThread().getName() + "剩余：" + count);

                    } else {
                        break;
                    }
                }
            }

        }
    }

排队解决这个问题的效率并不高，虽然分了三个线程但是仍然是在排队出票。

10.1.2线程不安全问题解决2：同步方法

和同步代码块相似，将方法修饰为同步。

    public static void main(String[] args){
        Runnable run = new MyRunnable();
        new Thread(run).start();
        new Thread(run).start();
        new Thread(run).start();

    }
    static class MyRunnable implements Runnable {
        private Object o = new Object();
        //票数
        private int count = 10;
        @Override
        public void run() {
            while(true) {
                boolean flag = sale();
                if(!flag){
                    break;
                }
            }

        }
        public synchronized boolean sale(){
            if (count > 0) {

                //卖票

                System.out.println("准备出票");

                //休眠一秒，增大线程抢占的几率
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                count--;
                System.out.println("出票完成" + Thread.currentThread().getName() + "剩余：" + count);
                return true;
            } else {
                return false;
            }
        }
    }

锁对象为this，如果是静态方法，锁是类名.class

如果同步方法的锁是this，同时又在一个同步代码块中上传了一个this的锁，这个锁将同时控制这两段代码。

10.1.3线程不安全问题解决3：显式锁Lock

同步代码块和同步方法都属于隐式锁

Lock 子类 ReentrantLock

    public static void main(String[] args){
        Runnable run = new MyRunnable();
        new Thread(run).start();
        new Thread(run).start();
        new Thread(run).start();

    }
    static class MyRunnable implements Runnable {
        private Object o = new Object();
        //票数
        private int count = 10;
        //显式锁 l
        private Lock l = new ReentrantLock();
        @Override
        public void run() {
            while(true) {
                l.lock();
                if (count > 0) {

                        //卖票

                        System.out.println("准备出票");

                        //休眠一秒，增大线程抢占的几率
                        try {
                            Thread.sleep(1000);
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                        count--;
                        System.out.println("出票完成"+Thread.currentThread().getName()+"剩余："+ count);

                }else{
                    break;
                }
                l.unlock();
            }

        }
    }

10.2显式锁和隐式锁

下面为转载内容，附上链接

在面试的过程中有可能会问到：在Java并发编程中，锁有两种实现：使用隐式锁和使用显示锁分别是什么？两者的区别是什么？所谓的显式锁和隐式锁的区别也就是说说Synchronized(下文简称：sync)和lock(下文就用ReentrantLock来代之lock)的区别。

Java中隐式锁：synchronized；显式锁：lock

sync和lock的区别

  1. 出身不同

    • 从sync和lock的出身(原始的构成)来看看两者的不同。
    • Sync:Java中的关键字，是由JVM来维护的。是JVM层面的锁。
    • Lock：是JDK5以后才出现的具体的类。使用lock是调用对应的API。是API层面的锁
    • sync是底层是通过monitorenter进行加锁（底层是通过monitor对象来完成的，其中的wait/notify等方法也是依赖于monitor对象的。只有在同步块或者是同步方法中才可以调用wait/notify等方法的。因为只有在同步块或者是同步方法中，JVM才会调用monitory对象的）；通过monitorexit来退出锁的。
    • 而lock是通过调用对应的API方法来获取锁和释放锁的。
    • 我们通过Javap命令来查看调用sync和lock的汇编指令：
      在这里插入图片描述

  2. 使用方式不同

    • Sync是隐式锁。Lock是显示锁
    • 所谓的显示和隐式就是在使用的时候，使用者要不要手动写代码去获取锁和释放锁的操作。
    • 我们大家都知道，在使用sync关键字的时候，我们使用者根本不用写其他的代码，然后程序就能够获取锁和释放锁了。那是因为当sync代码块执行完成之后，系统会自动的让程序释放占用的锁。Sync是由系统维护的，如果非逻辑问题的话话，是不会出现死锁的。
    • 在使用lock的时候，我们使用者需要手动的获取和释放锁。如果没有释放锁，就有可能导致出现死锁的现象。手动获取锁方法：lock.lock()。释放锁：unlock方法。需要配合tyr/finaly语句块来完成。

  3. 等待是否可中断

    • Sync是不可中断的。除非抛出异常或者正常运行完成

    • Lock可以中断的。中断方式：

      1. 调用设置超时方法tryLock(long timeout ,timeUnit unit)
      2. 调用lockInterruptibly()放到代码块中，然后调用interrupt()方法可以中断

  4. 加锁的时候是否可以公平

    • Sync;非公平锁
    • lock：两者都可以的。默认是非公平锁。在其构造方法的时候可以传入Boolean值。
      • true：公平锁
      • false：非公平锁

  5. 锁绑定多个条件来condition

    • Sync:没有。要么随机唤醒一个线程；要么是唤醒所有等待的线程。
    • Lock:用来实现分组唤醒需要唤醒的线程，可以精确的唤醒，而不是像sync那样，不能精确唤醒线程。

10.3公平锁和不公平锁

不公平锁：先抢到先得
上述三个解决线程不安全问题的方法都是不公平锁，只有Lock可以变为公平锁

公平锁：先来先到，每个人排队

参数为true 就表示为公平锁
Lock l = new ReentrantLock(true)

11.线程死锁

死锁的概念可以从一个例子来描述：
警匪片中警察会对劫匪说：你放了人质，我们就放你走；劫匪会说：你放我走，我才放人质。如果我们不考虑警察进一步的动作，我们可以把现在警察与劫匪的关系叫做死锁，下面用代码来演示：

    public static void main(String[] args) {
        //线程死锁
        //主线程控制罪犯说话，子线程控制警察说话
        Police p = new Police();
        Culprit c = new Culprit();
        new MyThread(p,c).start();
        c.say(p);
    }
    static class MyThread extends Thread {
        private Police p;
        private Culprit c;
        public MyThread(Police p,Culprit c){
            this.p = p;
            this.c = c;
        }

        @Override
        public void run() {
            p.say(c);
        }
    }
    //罪犯
    static class Culprit{
        public synchronized void say(Police p){
            System.out.println("罪犯：你放了我，我放人质");
            //劫匪说完话后，讨警察要一个回应
            p.answer();
        }
        //回应方法
        public synchronized void answer(){
            System.out.println("我放人质了，我走了");
        }
    }

    //警察
    static class Police{
        public synchronized void say(Culprit c){
            System.out.println("警察：你放人质，我放了你");
            //警察说完话后，向劫匪要一个回应
            c.answer();

        }
        //回应方法
        public synchronized void answer(){
            System.out.println("警察救了人质，我放走罪犯了");
        }
    }

运行截图：
在这里插入图片描述
就这样，死锁产生了。

12.多线程通信问题

首先了解几个Object 下的方法

变量和类型方法描述
voidnotify()唤醒正在此对象监视器上等待的单个线程。
voidnotifyAll()唤醒等待此对象监视器的所有线程。
voidwait()导致当前线程等待它被唤醒，通常是 通知或 中断 。
voidwait​(long timeoutMillis)导致当前线程等待它被唤醒，通常是 通知或 中断 ，或者直到经过一定量的实时。(参数：毫秒)
voidwait​(long timeoutMillis, int nanos)导致当前线程等待它被唤醒，通常是 通知或 中断 ，或者直到经过一定量的实时。 (参数：毫秒，纳秒)

12.1 生产者与消费者

这里用厨师与服务员来完成生产者与消费者的例子。
在这个例子里面，厨师完成一份菜后休息，唤醒服务生，服务生端完这份菜后休息，唤醒厨师，不考虑现实中的特殊情况。

    public static void main(String[] args) {
        Food f = new Food();
        new Cook(f).start();
        new Waiter(f).start();
    }

    //厨师
    static class Cook extends Thread{
        private Food f;
        public Cook(Food f) {
            this.f = f;
        }

        @Override
        public void run() {
            for(int i=0;i<100;i++){
                if(i%2==0){
                    f.setNameAndSaste("老干妈小米粥","香辣味");
                }else{
                    f.setNameAndSaste("煎饼果子","甜辣味");
                }
            }
        }
    }
    //服务生
    static class Waiter extends Thread{
        private Food f;
        public Waiter(Food f) {
            this.f = f;
        }
        @Override
        public void run() {
            for(int i=0;i<100;i++){
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                f.get();
            }
        }
    }
    //食物
    static class Food{
        private String name;
        private String taste;

        //true 表示可以生产
        private boolean flag = true;

        public synchronized void setNameAndSaste(String name,String taste){
            if(flag) {
                this.name = name;
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                this.taste = taste;
                flag = false;
                this.notifyAll();
                try {
                    this.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
        public synchronized void get(){
            if(!flag) {
                System.out.println("服务员端走的菜的名称是:" + name + ",味道:" + taste);
                flag = true;
                this.notifyAll();
                try {
                    this.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }

13.线程的六种状态

线程状态。 线程可以处于以下状态之一：

  • NEW ：尚未启动的线程处于此状态。
  • RUNNABLE ：在Java虚拟机中执行的线程处于此状态。
  • BLOCKED ：被阻塞等待监视器锁定的线程处于此状态。
  • WAITING ：无限期等待另一个线程执行特定操作的线程处于此状态。
  • TIMED_WAITING ：正在等待另一个线程执行最多指定等待时间的操作的线程处于此状态。
  • TERMINATED ：已退出的线程处于此状态。
    线程在给定时间点只能处于一种状态。 这些状态是虚拟机状态，不反映任何操作系统线程状态。

在这里插入图片描述
关系就类似与这种八爪鱼一样的。

14.带返回值的线程Callable

14.1Runnable 与 Callable

接口定义

//Callable接口
public interface Callable {
V call() throws Exception;
}
//Runnable接口
public interface Runnable {
public abstract void run();
}

14.2 Callable使用步骤

  1. 编写类实现Callable接口 , 实现call方法
class XXX implements Callable<T> {
	@Override
	public <T> call() throws Exception {
	return T;
	}
}
  1. 创建FutureTask对象 , 并传入第一步编写的Callable类对象
FutureTask<Integer> future = new FutureTask<>(callable);
  1. 通过Thread,启动线程
new Thread(future).start();

14.3Runnable 与 Callable的相同点

  • 都是接口
  • 都可以编写多线程程序
  • 都采用Thread.start()启动线程

14.4Runnable 与 Callable的不同点

  • Runnable没有返回值；Callable可以返回执行结果
  • Callable接口的call()允许抛出异常；Runnable的run()不能抛出

14.5Callable获取返回值

Callalble接口支持返回执行结果，需要调用FutureTask.get()得到，此方法会阻塞主进程的继续往下执行，如果不调用不会阻塞。

14.6实现Callable

在用代码完成之前，查看几个FutureTask的方法

变量和类型方法描述
protected voiddone()当此任务转换到状态 isDone （无论是正常还是通过取消），调用受保护的方法。
Vget()如果需要等待计算完成，然后检索其结果。
Vget​(long timeout, TimeUnit unit)如果需要，最多等待计算完成的给定时间，然后检索其结果（如果可用）。
protected booleanrunAndReset()执行计算而不设置其结果，然后将此未来重置为初始状态，如果计算遇到异常或被取消则无法执行此操作。
protected voidset​(V v)将此future的结果设置为给定值，除非已设置或已取消此未来。
protected voidsetException​(Throwable t)导致此未来报告带有给定throwable的ExecutionException作为其原因，除非此未来已设置或已取消。
StringtoString()返回此FutureTask的字符串表示形式。

实现代码示例：

    public static void main(String[] args) {
        Callable<Integer> c = new MyCallable();
        FutureTask<Integer> task = new FutureTask<>(c);
        new Thread(task).start();
        for (int i=0;i<10;i++){
            //加上休眠体现出并发执行的效果
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName()+":"+i);
        }
    }
    static class MyCallable implements Callable<Integer>{
        @Override
        public Integer call() throws Exception {
            //加上休眠体现出并发执行的效果
            for (int i=0;i<10;i++){
                Thread.sleep(1000);
                System.out.println(Thread.currentThread().getName()+":"+i);
            }
            return 100;
        }
    }

后半部分的运行截图：
在这里插入图片描述
使用一下FutureTask提供的get()方法，就用上面的例子，代码如下：

    public static void main(String[] args) throws ExecutionException, InterruptedException {
        Callable<Integer> c = new MyCallable();
        FutureTask<Integer> task = new FutureTask<>(c);
        new Thread(task).start();
        
        //get方法在这，有异常直接抛出了
        Integer j = task.get();
        System.out.println("返回值为："+j);
        
        for (int i=0;i<10;i++){
            //加上休眠体现出并发执行的效果
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName()+":"+i);
        }
    }
    static class MyCallable implements Callable<Integer>{
        @Override
        public Integer call() throws Exception {
            //加上休眠体现出并发执行的效果
            for (int i=0;i<10;i++){
                Thread.sleep(1000);
                System.out.println(Thread.currentThread().getName()+":"+i);
            }
            return 100;
        }
    }

get方法会先让子线程结束，运行截图：
在这里插入图片描述

15.线程池

15.1线程池概述Executors

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

线程池就是一个容纳多个线程的容器，池中的线程可以反复使用，省去了频繁创建线程对象的操作，节省了大量的时间和资源。
优点：

  • 降低资源消耗。
  • 提高响应速度。
  • 提高线程的可管理性。

15.2Java中的四种线程池 ExecutorService

1. 缓存线程池. (长度无限制)
执行流程:

  1. 判断线程池是否存在空闲线程
  2. 存在则使用
  3. 不存在,则创建线程 并放入线程池, 然后使用
ExecutorService service = Executors.newCachedThreadPool();
//向线程池中 加入 新的任务
service.execute(new Runnable() {
	@Override
	public void run() {
		System.out.println("线程的名称:"+Thread.currentThread().getName());
	}
});
service.execute(new Runnable() {
	@Override
	public void run() {
		System.out.println("线程的名称:"+Thread.currentThread().getName());
	}
});
service.execute(new Runnable() {
	@Override
	public void run() {
		System.out.println("线程的名称:"+Thread.currentThread().getName());
	}
});

2. 定长线程池
定长线程池.(长度是指定的数值)
执行流程:

  1. 判断线程池是否存在空闲线程
  2. 存在则使用
  3. 不存在空闲线程,且线程池未满的情况下,则创建线程 并放入线程池, 然后使用
  4. 不存在空闲线程,且线程池已满的情况下,则等待线程池存在空闲线程
ExecutorService service = Executors.newFixedThreadPool(2);
service.execute(new Runnable() {
	@Override
	public void run() {
		System.out.println("线程的名称:"+Thread.currentThread().getName());
	}
});
service.execute(new Runnable() {
	@Override
	public void run() {
		System.out.println("线程的名称:"+Thread.currentThread().getName());
	}
});

3.单线程线程池
效果与定长线程池 创建时传入数值1 效果一致.

单线程线程池.
执行流程:

  1. 判断线程池 的那个线程 是否空闲
  2. 空闲则使用
  3. 不空闲,则等待 池中的单个线程空闲后 使用
ExecutorService service = Executors.newSingleThreadExecutor();
service.execute(new Runnable() {
	@Override
	public void run() {
		System.out.println("线程的名称:"+Thread.currentThread().getName());
	}
});
service.execute(new Runnable() {
	@Override
	public void run() {
		System.out.println("线程的名称:"+Thread.currentThread().getName());
	}
});

4… 周期性任务定长线程池

public static void main(String[] args) {
	/**
	* 周期任务 定长线程池.
	* 执行流程:
	*	 1. 判断线程池是否存在空闲线程
	*	 2. 存在则使用
	*	 3. 不存在空闲线程,且线程池未满的情况下,则创建线程 并放入线程池, 然后使用
	*	 4. 不存在空闲线程,且线程池已满的情况下,则等待线程池存在空闲线程
	*
	* 周期性任务执行时:
	* 		定时执行, 当某个时机触发时, 自动执行某任务 .
	*/
	ScheduledExecutorService service = Executors.newScheduledThreadPool(2);


	/**
	* 定时执行
	* 参数1.		 runnable类型的任务
	* 参数2.		 时长数字
	* 参数3. 	 时长数字的单位
	*/
	/*service.schedule(new Runnable() {
		@Override
		public void run() {
			System.out.println("俩人相视一笑~ 嘿嘿嘿");
		}
	},5,TimeUnit.SECONDS);
	*/


	/**
	* 周期执行
	* 参数1. runnable类型的任务
	* 参数2. 时长数字(延迟执行的时长)
	* 参数3. 周期时长(每次执行的间隔时间)
	* 参数4. 时长数字的单位
	*/
	service.scheduleAtFixedRate(new Runnable() {
		@Override
		public void run() {
			System.out.println("俩人相视一笑~ 嘿嘿嘿");
		}
	},5,2,TimeUnit.SECONDS);
}

16.Lambda表达式

Lambda表达式是函数式编程思想
先用实现Runnable来观察一下Lambda表达式

    public static void main(String[] args) {
        //冗余的Runnable代码
        /*
        Thread t = new Thread(new Runnable(){

            @Override
            public void run() {
                System.out.println("锄禾日当午");
            }
        });
        t.start();
        */
        
        //Lambda表达式
        Thread t = new Thread(() -> {
            System.out.println("锄禾日当午");
        });
        t.start();
    }

下面用自己定义的实现接口来进一步了解

    public static void main(String[] args) {
        //普通写法
        /*
        print(new MyMath(){

            @Override
            public int sum(int x, int y) {
                return x+y;
            }
        },100,200);
        */

        //Lambda表达式
        print((int x, int y) -> {
                return x+y;
            },100,200);
    }

    public static void print(MyMath m, int x, int y){
        int num = m.sum(x,y);
        System.out.println(num);
    }

    static interface MyMath{
        int sum(int x,int y);
    }
详解Java多线程处理List数据
08-26
详解Java多线程处理List数据 Java多线程处理List数据是指在Java编程中，使用多线程技术来处理List数据的操作。这种操作可以提高程序的执行效率和性能，特别是在处理大规模数据时。下面将详细介绍Java多线程处理List...
JAVA多线程的使用场景与注意事项总结
08-26
JAVA多线程的使用场景与注意事项总结 Java多线程是Java语言中的一种重要机制，允许程序同时执行多个任务，以提高程序的执行效率和响应速度。在Java中，多线程可以通过继承Thread类、实现Runnable接口或使用线程池来...
菜鸟的进阶之路:了解使用多线程
weixin_38328252的博客
05-25 215
温馨提示如果你喜欢本文，请分享到朋友圈，想要获得更多信息，请关注我。小菜鸟大菜鸟，什么是多线程？多线程其实就是指一个程序运行时产生多个线程去执行。大菜鸟小菜鸟哦哦，那多线程和多进程有什么...
Java学习记录（多线程）
Geraint_Tan的博客
07-20 237
多线程 多线程 线程与进程 概念： 进程： 是指一个内存中运行的应用程序，每个进程都有一个独立的内存空间 线程： 是进程中的一个执行路径，共享一个内存空间，线程之间可以自由切换，并发执行. 一个进程最少有一个线程 线程实际上是在进程基础之上的进一步划分，一个进程启动之后，里面的若干执行路径又可以划分成若干个线程 线程调度： 分时调度： 所有线程轮流使用 CPU 的使用权，平均分配每个线程占用 CPU 的时间。 抢占式调度： 优先让优先级高的线程使用 CPU，如果线程的优先级相同，那么会随机选
《菜鸟记基础篇11》——多线程
weixin_44850737的博客
07-15 321
菜鸟记所有篇章都是个人随手记，可能存在知识点遗漏，请多包涵。 本篇章的菜鸟记 概念居多。 本篇目录一、多线程理论二、如何实现多线程1.Thread类2.实现Runnable接口2.1线程同步问题（同步锁）3.实现Callable接口/线程的生命周期二、死锁1.线程阻塞对列 ArrayBlockingQueue三、并发1Lock锁2闭锁：3线程八锁：4线程池5.volatile:关键字/原子变量类6.线程之间的通讯: Condition7.读写锁8.分支合并框架ForkJoinPool 一、多线程理论 多
菜鸟的java多线程学习总结
最强菜鸟
07-13 675
菜鸟的java多线程学习总结说明一、多线程创建（1）继承Thread类（2）实现Runnable接口（3）线程池 说明 更新时间：2020/7/3 17:32，更新了锁机制和SQL语句优化 更新时间：2020/7/2 17:29，更新了索引 更新时间：2020/7/1 22:35，更新了SQL解析及优化，未完待续… 一直想学习一下mysql进阶的相关知识，刚好趁着前段时间redis学完，可以学习一下mysql的进阶，简单了解了一下进阶的相关知识，还挺多的，感觉之前的mysql学的好像只是简单入门而已。本文会
线程的并发、并行以及高并发
cccrush的博客
09-30 8789
并发：   当多个线程在操作的时候，如果系统只有一个CPU，同一时刻就只有一条线程指令在执行，但是各个线程指令被快速的轮换执行，这就是的宏观上看起来是多个线程在同时执行。但微观上并不是这样，只是将时间分成若干个片段，多个线程交替执行。 如图系统只有1个CPU，线程就要通过竞争得到执行机会。谁得到CPU谁就执行。                                        ...
实战指南：理解 ThreadLocal 原理并用于Java 多线程上下文管理
最新发布
曾经“等你生日那天”都遥远得像未来，如今却可欢愉的挥手说“下个十年见”
12-01 10万+
探讨如何基于实现一个高效的上下文管理组件，以解决多线程环境下的数据共享和上下文管理这些问题。通过具体的代码示例和实战展示如何为多线程编程提供一种简洁而高效的上下文管理方案。
java多线程实现大批量数据导入源码
09-29
本项目以"java多线程实现大批量数据导入源码"为题，旨在通过多线程策略将大量数据切分，并进行并行处理，以提高数据处理速度。 首先，我们需要理解Java中的线程机制。Java通过`Thread`类来创建和管理线程。每个线程...
精选资源
JAVA多线程技术分享-39页PPT(winding)
05-10
Java多线程技术是软件开发中的重要组成部分，尤其在高并发场景下不可或缺。本文将深入探讨多线程技术的关键知识点，以及在实际开发中容易遇到的问题。 首先，基础概念是理解多线程的关键。`Thread.sleep(0)`看似无...
【多线程那些事儿】多线程的执行顺序如你预期吗？
Gefangenes的博客
06-27 328
这样，当第一条指令在执行的时候，第二条指令可以进行译码，第三条指令可以进行取指...于是CPU被充分利用了，指令的执行效率也大大提高。嗯...我们又仔细的回顾了一下自己的分析过程：在m和n被赋值的时候，x = 1和y = 1至少有一条语句被执行了...没有问题，那应该就不会出现m和n都是0的情况。那我们在编译的时候把-O3优化选项去掉，尽量让编译器不要进行优化，保持原来的指令执行顺序，应该就可以避免m和n同时为0的结果了吧？跟我们的预期一致，汇编代码保持了原来的执行顺序，这回肯定没有问题了。
在多核计算机上执行多线程的程序,为什么只有一个cpu在运行,计算机只有一个CPU为什么能同时运行多个软件...
weixin_32494473的博客
07-15 4051
中央处理器(CPU)，是电子计算机中的核心配件,相当于人的大脑，人的大脑可以控制人的身体，而计算机的大脑CPU可以控制计算机。CPU的功能主要是解释计算机指令以及处理计算机软件中的数据。我们打开任务管理器，就会发现其实一个系统中运行了多个程序，这就给我们造成了一个假象，就是我们电脑可以同时运行很多很多程序，其实不是的。在某一时刻，只有一个程序在运行！我们的电脑运行多个程序，但是他们并不是并行的，而...
java面试题---多线程
lydon1314的博客
10-15 373
线程是java基础的一个重要知识，对于java来说，程序在运行使用时要创建线程，而为了使用线程方便，我们有创建衍生出了线程池来对于线程进行统一的管理。本文就从线程基础，线程的实现，线程池三个方面说说线程的相关知识。
共识与一致性
No smile博客
07-26 3294
此文为缝合的结果，来源见参考。 本文为学习所用，如有侵权请告知本人。 共识与一致性 共识描述了分布式系统中多个节点之间，彼此对某个状态达成一致结果的过程。 在实践中，要保障系统满足不同程度的一致性，核心过程往往需要通过共识算法来达成。 共识算法解决的是对某个提案（proposal）大家达成一致意见的过程。提案的含义在分布式系统中十分宽泛，如多个事件发生的顺序、某个键对应的值、谁是领导……等等。可以认为任何可以达成一致的信息都是一个提案。对于分布式系统来讲，各个节点通常都是相同的确定性状态机模型（又称.
史上最全的Unity面试题（含答案）
崔小妹儿Jessica的博客
12-13 3万+
一：什么是协同程序？ 在主线程运行的同时开启另一段逻辑处理，来协助当前程序的执行，协程很像多线程，但是不是多线程，Unity的协程实在每帧结束之后去检测yield的条件是否满足。 二：Unity3d中的碰撞器和触发器的区别？ 碰撞器是触发器的载体，而触发器只是碰撞器身上的一个属性。当Is Trigger=false时，碰撞器根据物理引擎引发碰撞，产生碰撞的效果，可以调用OnCol
多线程知识（一）初识多线程
liuerchong的博客
07-03 188
多线程快速入门 一、本课目标 线程与进程区别 为什么要使用多线程？ 多线程应用场景 多线程创建方式 二、线程与进程区别 每个正在系统上运行的程序都是一个进程。每个进程包含一到多个线程。线程是一组指令的集合，或者是程序的特殊段，它可以在程序里独立执行。也可以把它理解为代码运行的上下文。所以线程基本上是轻量级的进程，它负责在单个程序里执行多任务。通常由操作系统负责多个线程的调度和执行。 使用线程可以把占据时间长的程序中的任务放到后台去处理，程序的运行速度可能加快，在一些等待的任务实现上如用户输入
Java基础面试题(下)
小猪呀的博客
09-16 1190
1.Collection下的常用子类集合有那一些？ 有List，Set。 List：有序(按添加顺序显示)，可重复，set：无序(按大小排序显示)，不可重复，map：以键值对方式存储 List分别有： ArrayList：是List的主要实现类，ArrayList的底层是数组。线程不安全的。查找快，增删慢(通过首地址+下标获取元素位置，增删要移动某一些元素)” LinkedList：底层是一个双向链表(是一个带头/尾指针的双向链表，)。插入，删除快（增删快因为直接就在对应的位置设置新的元素指向前后
Java笔试题【7】
凯撒晓弟
04-02 911
一、基础问答     不能被继承的类有[Long  Double Float  Short  Void Class  Math  String]     他们都被final修饰         类可以被继承[Thread   ClassLoader  Number Calendar ] 　　1.下面哪些类可以被继承? 　　　java.lang.Thread (T) 　　　java.l
java基础面试题
xiaotai1234的博客
05-13 2125
java基础 1.描述一下值传递和引用传递的区别 java中只有值传递，没有引用传递 详解 2.== 和 equals 区别是什么、String 中的 equals 方法是如何重写的、为什么要重写 equals 方法、为什么要重写 hashCode 方法 == 和 equals 区别是什么 String中的equals方法是如何重写的 public boolean equals(Object anObject) { if (this == anObject) { return tr
评论 1
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值