Java学习-线程

最新推荐文章于 2024-08-18 16:24:30 发布
原创 最新推荐文章于 2024-08-18 16:24:30 发布
· 136 阅读 · 0 ·
版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#java #学习 #jvm

1 概述

什么是线程?

  • 线程(thread)是一个程序内部的一条执行路径。

我们之前启动程序执行后，main方法的执行其实就是一条 单独的执行路径。

  • 程序中如果只有一条执行路径，那么这个程序就是单线程的程序。

多线程是什么?

  • 多线程是指从软硬件上实现多条执行流程的技术。

2 多线程的创建

2.1 Thread类

  • Java是通过java.lang.Thread 类来代表线程的。
  • 按照面向对象的思想，Thread类应该提供 了实现多线程的方式。
     

多线程的实现方案一:继承Thread类
①定义一个子类MyThread继承线程类java.lang.Thread,重写run()方法
②创建MyThread类的对象
③调用线程对象的start()方法启动线程(启动后还是执行run方法的)

package com.itzw.d1_thread;

public class ThreadTest01 {
    public static void main(String[] args) {
        Thread t = new MyThread();
        t.start();
        for (int i = 0; i < 5; i++) {
            System.out.println("主线程执行了"+i);
        }
    }
}

class MyThread extends Thread{
    @Override
    public void run() {
        for (int i = 0; i < 5; i++) {
            System.out.println("子线程执行了" + i);
        }
    }
}

结果每次都会有差别 

主线程执行了0
子线程执行了0
主线程执行了1
子线程执行了1
主线程执行了2
子线程执行了2
主线程执行了3
子线程执行了3
主线程执行了4
子线程执行了4

方式一优缺点:

  • 优点:编码简单
  • 缺点:线程类已经继承Thread,无法继承其他类,不利于扩展。
     

1、为什么不直接调用了run方法，而是调用start启动线程。

  • 直接调用run方 法会当成普通方法执行，此时相当于还是单线程执行。
  • 只有调用start方法才是启动一个新的线程执行。

2、把主线程任务放在子线程之前了。

  • 这样主线程一直是先跑完的相当于是一个单线程的效果了。

2.2 Runnable

多线程的实现方案二:实现Runnable接0
①定义一个线程任务类MyRunnable实现Runnable接口，重写run()方法
②创建MyRunnable任务 对象
③把MyRunnable任务 对象交给Thread处理。
④调用线程对象的start()方法启动线程的

Thread的构造器
public Thread(String name)可以为当前线程指定名称
public Thread(Runnable targ李)封装Runnable对象成为线程对象
public Thread(Runnable target，String name )封装Runnable对象成为线程对象，并指定线程名称

方式二优缺点:
优点:线程任务类只是实现接口，可以继续继承类和实现接口，扩展性强。
缺点:编程多一层对象包装,如果线程有执行结果是不可以直接返回的。
 

package com.itzw.d2_Runnable;

public class RunnableTest{
    public static void main(String[] args) {
        //创建一个任务对象
        Runnable target = new MyRunnable();
        //把任务对象交给Thread处理
        Thread t = new Thread(target);
        //启动线程
        t.start();

        for (int i = 0; i < 10; i++) {
            System.out.println("主线程执行了" + i);
        }

    }
}

class MyRunnable implements Runnable{

    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            System.out.println("子程序执行了" + i);
        }
    }
}

2.3 Runnable(匿名内部类)

package com.itzw.d2_Runnable;

public class RunnableTest02{
    public static void main(String[] args) {
        //创建一个任务对象
        Runnable target = new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < 10; i++) {
                    System.out.println("子程序执行了"+i);
                }

            }
        };
        //把任务对象交给Thread处理
        Thread t = new Thread(target);
        //启动线程
        t.start();

        new Thread(()->{
                for (int i = 0; i < 10; i++) {
                    System.out.println("子线程2执行了"+i);
                }
        }).start();


        for (int i = 0; i < 10; i++) {
            System.out.println("主线程执行了" + i);
        }

    }
}

2.4 Callable

1、前2种线程创建方式都存在一个问题:

  • 他们重写的run方法均不能直接返回结果。
  • 不适合需要返回线程执行结果的业务场景。

2、怎么解决这个问题呢?

  • jDK 5.0提供了Callable和FutureTask来实现。

①、得到任务对象
        1. 定义类实现Callable接口，重写call方法，封装要做的事情。
        2.用FutureTask把Callable对 象封装成线程任务对象。
②、 把线程任务对象交给Thread处理。
③、调用Thread的start方法启动线程，执行任务

 方式三优点:

  • 优点:线程任务类只是实现接口，可以继续继承类和实现接口,扩展性强。
  • 可以在线程执行完毕后 去获取线程执行的结果。
package com.itzw.d3_callablle;

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;

public class CallableTest {
    public static void main(String[] args) {
        // 创建Callable任务对象
        Callable<String> call = new MyCallabel(100);
        // 把Callable任务对象 交给FutureTask 对象
        // FutureTask对象的作用1:是Runnable的对象 (实现了Runnable接口)，可以交给Thread了
        // FutureTask对象的作用2:可以在线程执行完毕之后通过调用其get方法得到线程执行完成的结果
        FutureTask<String> f1 = new FutureTask<>(call);
        Thread t1 = new Thread(f1);
        t1.start();

        Callable<String> call2 = new MyCallabel(200);
        FutureTask<String> f2 = new FutureTask<>(call2);
        Thread t2 = new Thread(f2);
        t2.start();

        try {
            String s1 = f1.get();
            System.out.println("第一个结果:"+s1);
        } catch (Exception e) {
            e.printStackTrace();
        }
        try {
            String s2 = f2.get();
            System.out.println("第二个结果:"+s2);
        } catch (Exception e) {
            e.printStackTrace();
        }


    }
}

class MyCallabel implements Callable<String>{
    private int n;
    public MyCallabel(int n) {
        this.n = n;
    }

    @Override
    public String call() throws Exception {
        int sum = 0;
        for (int i = 1; i <= n; i++) {
            sum += i;
        }
        return "和为:" + sum;
    }
}

3 线程常用方法

Thread类获得当前线程的对象
public static Thread currentThread():返回对当前正在执行的线程对象的引用
注意
1、此方法是Thread类的静态方法，可以直接使用Thread类调用。
2、这个方法是在哪个线程执行中调用的，就会得到哪个线程对象。
 

package com.itzw.d4_api;

public class CurrentThreadTest {
    public static void main(String[] args) {
        Thread t1 = new MyThread("子线程1");
        t1.start();
        System.out.println(t1.getName());

        Thread t2 = new MyThread();
        t2.setName("子线程2");
        t2.start();
        System.out.println(t2.getName());

        //获得当前线程，也就是主线程
        Thread m = Thread.currentThread();

        System.out.println(m.getName());
        for (int i = 0; i < 5; i++) {
            System.out.println("主线程执行了" + i);
        }
    }
}

class MyThread extends Thread{
    public MyThread(){
    }
    public MyThread(String name){
        super(name);
    }
    @Override
    public void run() {
        for (int i = 0; i < 5; i++) {
            System.out.println(Thread.currentThread().getName()+"子线程执行了" + i);
        }

    }
}

Thread类的线程休眠方法
public static void sleep(long time)让当前线程休眠指定的时间后再继续执行，单位为毫秒。
 

    public static void main(String[] args) throws InterruptedException {
        for (int i = 0; i < 5; i++) {
            System.out.println(i);
            if (i == 3){
                Thread.sleep(3000);//3秒
            }
        }
    }

4 线程安全问题

4.1 问题

  • 多个线程同时操作同一个共享资源的时候可能会出现业务安全问题，称为线程安全问题。

取钱模型演示

  • 需求: 小明和小红是一-对夫妻,他们有一个共同的账户，余额是10万元。
  • 如果小明和小红同时来取钱，而且2人都要取钱10万元，可能出现什么问题呢?
     

线程安全问题出现的原因?

  • 存在多线程并发
  • 同时访问共享资源
  • 存在修改共享资源

取钱业务
需求:

  • 小明和小红是一对夫妻,他们有一个共同的账户，余额是1万元，模拟2人同时去取钱1万。

分析:
①:需要提供一个账户类,创建-一个账户对象代表2个人的共享账户。
②:需要定义一个线程类,线程类可以处理账户对象。
③:创建2个线程对象,传入同一个账户对象。
④:启动2个线程，去同一个账户对象中取钱1万。

代码如下：

账户类

package com.itzw.d5_thread_safe;

public class Account {
    private String carId;
    private double money;

    public Account() {
    }

    public Account(String carId, double money) {
        this.carId = carId;
        this.money = money;
    }

    public String getCarId() {
        return carId;
    }

    public void setCarId(String carId) {
        this.carId = carId;
    }

    public double getMoney() {
        return money;
    }

    public void setMoney(double money) {
        this.money = money;
    }

    public void drawMoney(double money) {
        String name = Thread.currentThread().getName();
        if (this.money >= money){
            //可以取钱
            System.out.println(name + "取钱成功，吐出" + money);
            //更新余额
            this.money -= money;
            System.out.println(name + "取钱后余额为：" + this.money);
        }else {
            System.out.println(name + "取钱余额不足");
        }
    }
}

取钱线程

package com.itzw.d5_thread_safe;

public class DrawThread extends Thread{
    private Account acc;
    public DrawThread(Account acc,String name){
        super(name);
        this.acc = acc;
    }
    @Override
    public void run() {
        //取钱
        acc.drawMoney(10000);
    }
}

测试

package com.itzw.d5_thread_safe;

public class ThreadTest {
    public static void main(String[] args) {
        //创建一个账户，小明和小红共享的
        Account acc = new Account("ICBD-12356789",10000);
        //取钱
        new DrawThread(acc,"小明").start();
        new DrawThread(acc,"小红").start();
    }
}

小红取钱成功，吐出10000.0
小明取钱成功，吐出10000.0
小红取钱后余额为：0.0
小明取钱后余额为：-10000.0

4.2 解决方法

如何才能保证线程安全呢?

  • 让多个线程实现先后依次访问共享资源，这样就解决了安全问题

线程同步的核心思想

  • 加锁，把共享资源进行上锁,每次只能一个线程进入访问完毕以后解锁，然后其他线程才能进来。

4.2.1 同步代码块

  • 作用:把出现线程安全问题的核心代码给上锁。
  • 原理:每次只能一个线程进入，执行完毕后自动解锁，其他线程才可以进来执行。

synchronized(同步锁对象) {
        操作共享资源的代码(核心代码)
}


锁对象要求

  • 理论上:锁对象只要对于当前同时执行的线程来说是同一个对象即可。

 

小明取钱成功，吐出10000.0
小明取钱后余额为：0.0
小红取钱余额不足

锁对象用任意唯一的对象好不好呢?

  • 不好，会影响其他无关线程的执行。

锁对象的规范要求

  • 规范上:建议使用共享资源作为锁对象。

锁对象的规范要求

  • 规范上:建议使用共享资源作为锁对象。
  • 对于实例方法建议使用this作为锁对象。
  • 对于静态方法建议使用字节码(类名.class) 对象作为锁对象。

4.2.2 同步方法

  • 作用:把出现线程安全问题的核心方法给上锁。
  • 原理:每次只能一个线程进入，执行完毕以后自动解锁，其他线程才可以进来执行。

同步方法底层原理

  • 同步方法其实底层也是有隐式锁对象的，只是锁的范围是整个方法代码。
  • 如果方法是实例方法:同步方法默认用this作为的锁对象。但是代码要高度面向对象!
  • 如果方法是静态方法:同步方法默认用类名.class作为的锁对象。

4.2.2 lock锁 

  • 为了更清晰的表达如何加锁和释放锁，JDK5以后提供了一个新的锁对象Lock,更加灵活、方便。
  • Lock实现提供比使用synchronized方法和语句可以获得更广泛的锁定操作。
  • Lock是接口不能直接实例化，这里采用它的实现类ReentrantLock来构建Lock锁对象。

public ReentrantLock()                获得Lock锁的实现类对象
Lock的API
void lock()                获得锁
void unlock()                释放锁

5 线程通信 

什么是线程通信、如何实现?

  • 所谓线程通信就是线程间相互发送数据，线程通信通常通过共享一个数据的方式实现。
  • 线程间会根据共享数据的情况决定自己该怎么做，以及通知其他线程怎么做。

线程通信常见模型

  • 生产者与消费者模型:生产者线程负责生产数据，消费者线程负责消费数据。
  • 要求:生产者线程生产完数据后，唤醒消费者,然后等待自己;消费者消费完该数据后,唤醒生产者,然后等待自己。
     

线程通信的三个常见方法

void wait( )                当前线程等待，直到另一个线程调用notify()或notifyA11()唤醒自己
void notify()                唤醒正在等待对象监视器(锁对象)的单个线程
void notifyAl1()            唤醒正在等待对象监视器(锁对象)的所有线程

注意

  • 上述方法应该使用当前同步锁对象进行调用。

案例：

账户类

package com.itzw.d6_thread_communication;

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class Account {
    private String carId;
    private double money;
    //final修饰，不可修改锁
    private final Lock lock = new ReentrantLock();
    public Account() {
    }

    public Account(String carId, double money) {
        this.carId = carId;
        this.money = money;
    }

    public synchronized void drawMoney(double money) {
        try {
            String name = Thread.currentThread().getName();
            if (this.money >= money){
                //可以取钱
                this.money -= money;
                System.out.println(name + "取钱" + money + "成功，余额:" + this.money);
                //没钱了
                this.notifyAll();
                this.wait();
            }else {
                //余额不足
                this.notifyAll();//唤醒其它所有线程
                //唤醒后自己等待、睡眠
                this.wait();
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    public synchronized void DepositeMoney(double money) {
        try {
            String name = Thread.currentThread().getName();
            if (this.money <= 0){
                //存钱
                this.money += money;
                System.out.println(name + "存钱" + money + "成功，余额为:" + this.money);
                //存钱结束
                this.notifyAll();
                this.wait();
            }else {
                //不需要存钱
                this.notifyAll();
                this.wait();
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    public String getCarId() {
        return carId;
    }

    public void setCarId(String carId) {
        this.carId = carId;
    }

    public double getMoney() {
        return money;
    }

    public void setMoney(double money) {
        this.money = money;
    }


}

存钱线程

package com.itzw.d6_thread_communication;
//存钱线程
public class DepositeThread extends Thread{
    private Account acc;
    public DepositeThread(Account acc, String name){
        super(name);
        this.acc = acc;
    }
    @Override
    public void run() {
        //取钱
        while (true) {
            acc.DepositeMoney(10000);
            try {
                Thread.sleep(3000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

取钱线程

package com.itzw.d6_thread_communication;
//取钱线程
public class DrawThread extends Thread{
    private Account acc;
    public DrawThread(Account acc, String name){
        super(name);
        this.acc = acc;
    }
    @Override
    public void run() {
        //取钱
        while (true) {
            acc.drawMoney(10000);
            try {
                Thread.sleep(3000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

测试

package com.itzw.d6_thread_communication;

public class ThreadTest {
    public static void main(String[] args) {
        //创建一个账户，小明和小红（消费者）共享的，亲爹、岳父、干爹（生产者）也共享
        Account acc = new Account("ICBD-12356789",0);
        //小红和小明取钱
        new DrawThread(acc,"小明").start();
        new DrawThread(acc,"小红").start();

        //亲爹、岳父、干爹存钱
        new DepositeThread(acc,"亲爹").start();
        new DepositeThread(acc,"干爹").start();
        new DepositeThread(acc,"岳父").start();
    }
}

亲爹存钱10000.0成功，余额为:10000.0
小明取钱10000.0成功，余额:0.0
亲爹存钱10000.0成功，余额为:10000.0
小红取钱10000.0成功，余额:0.0
岳父存钱10000.0成功，余额为:10000.0
小明取钱10000.0成功，余额:0.0

6 线程池

6.1 概述

什么是线程池?

  • 线程池就是一个可以复用线程的技术。

不使用线程池的问题

  • 如果用户每发起一一个请求,后台就创建一个新线程来处理，下次新任务来了又要创建新线程，而创建新线程的开销是很大的，这样会严重影响系统的性能。

6.2 常用API

谁代表线程池?

  • JDK 5.0起提供了代表线程池的接口: ExecutorService

如何得到线程池对象

  • 方式一:使用ExecutorService的实 现类ThreadPoolExecutor自创建一个线程池对象
  • 方式二:使用Executors (线程池的工具类)调用方法返回不同特点的线程池对象

线程池常见面试题
临时线程什么时候创建啊?

  • 新任务提交时发现核心线程都在忙，任务队列也满了，并且还可以创建临时线程，此时才会创建临时线程。

什么时候会开始拒绝任务?

  • 核心线程和临时线程都在忙，任务队列也满了，新的任务过来的时候才会开始任务拒绝。

6.3 线程池处理Runnable任务

演示：

package com.itzw.d7_threadpool;

public class MyRunnable implements Runnable {
    @Override
    public void run() {
        for (int i = 0; i < 5; i++) {
            System.out.println(Thread.currentThread().getName()+"输出流HelloWorld->"+i);
        }
    }
}

 本次创建三个核心线程，最大线程5个，也就是临时线程2个，有5个位置用来等待，也就是这5个位置没满临时线程不会创建。

package com.itzw.d7_threadpool;

import java.util.TimerTask;
import java.util.concurrent.*;

public class ThreadPoolTest {
    public static void main(String[] args) {
        //1.创建线程池对象
        /**
         *    public ThreadPoolExecutor(int corePoolSize,
         *                               int maximumPoolSize,
         *                               long keepAliveTime,
         *                               TimeUnit unit,
         *                               BlockingQueue<Runnable> workQueue,
         *                               ThreadFactory threadFactory,//用来创建线程
         *                               RejectedExecutionHandler handler)
         */
        ExecutorService pool = new ThreadPoolExecutor(3,5,6, TimeUnit.SECONDS,
                new ArrayBlockingQueue<>(5), Executors.defaultThreadFactory(),
                new ThreadPoolExecutor.AbortPolicy());

        //2.给任务线程池处理
        Runnable target = new MyRunnable();
        pool.execute(target);
        pool.execute(target);
        pool.execute(target);
        pool.execute(target);
        pool.execute(target);
    }
}

运行结果，发现因为任务简单，指定的三个核心线程完全够用，不需要等待也不需要创建临时线程

pool-1-thread-2输出流HelloWorld->0
pool-1-thread-1输出流HelloWorld->0
pool-1-thread-3输出流HelloWorld->0
pool-1-thread-1输出流HelloWorld->1
pool-1-thread-2输出流HelloWorld->1
pool-1-thread-1输出流HelloWorld->2
pool-1-thread-3输出流HelloWorld->1
pool-1-thread-1输出流HelloWorld->3
pool-1-thread-2输出流HelloWorld->2
pool-1-thread-1输出流HelloWorld->4
pool-1-thread-3输出流HelloWorld->2
pool-1-thread-1输出流HelloWorld->0
pool-1-thread-2输出流HelloWorld->3
pool-1-thread-1输出流HelloWorld->1
pool-1-thread-3输出流HelloWorld->3
pool-1-thread-1输出流HelloWorld->2
pool-1-thread-2输出流HelloWorld->4
pool-1-thread-1输出流HelloWorld->3
pool-1-thread-3输出流HelloWorld->4
pool-1-thread-1输出流HelloWorld->4
pool-1-thread-2输出流HelloWorld->0
pool-1-thread-2输出流HelloWorld->1
pool-1-thread-2输出流HelloWorld->2
pool-1-thread-2输出流HelloWorld->3
pool-1-thread-2输出流HelloWorld->4

共有八个任务，但仍不会创建临时线程 

pool-1-thread-2输出流HelloWorld->0
pool-1-thread-1输出流HelloWorld->0
pool-1-thread-3输出流HelloWorld->0
pool-1-thread-1输出流HelloWorld->1
pool-1-thread-2输出流HelloWorld->1
pool-1-thread-1输出流HelloWorld->2
pool-1-thread-3输出流HelloWorld->1
pool-1-thread-1输出流HelloWorld->3
pool-1-thread-2输出流HelloWorld->2
pool-1-thread-1输出流HelloWorld->4
pool-1-thread-3输出流HelloWorld->2
pool-1-thread-2输出流HelloWorld->3
pool-1-thread-3输出流HelloWorld->3
pool-1-thread-2输出流HelloWorld->4
pool-1-thread-3输出流HelloWorld->4
pool-1-thread-2进入休眠
pool-1-thread-3进入休眠
pool-1-thread-1进入休眠

 创建9个任务，此时3个核心线程没有忙完，5个等待位置也已经满了，所以只能创建临时线程。 

 

pool-1-thread-4输出流HelloWorld->0
pool-1-thread-2输出流HelloWorld->0
pool-1-thread-3输出流HelloWorld->0
pool-1-thread-1输出流HelloWorld->0
pool-1-thread-3输出流HelloWorld->1
pool-1-thread-2输出流HelloWorld->1
pool-1-thread-4输出流HelloWorld->1
pool-1-thread-2输出流HelloWorld->2
pool-1-thread-3输出流HelloWorld->2
pool-1-thread-1输出流HelloWorld->1
pool-1-thread-3输出流HelloWorld->3
pool-1-thread-2输出流HelloWorld->3
pool-1-thread-4输出流HelloWorld->2
pool-1-thread-2输出流HelloWorld->4
pool-1-thread-3输出流HelloWorld->4
pool-1-thread-1输出流HelloWorld->2
pool-1-thread-1输出流HelloWorld->3
pool-1-thread-4输出流HelloWorld->3
pool-1-thread-4输出流HelloWorld->4
pool-1-thread-1输出流HelloWorld->4
pool-1-thread-2进入休眠
pool-1-thread-3进入休眠
pool-1-thread-4进入休眠
pool-1-thread-1进入休眠

 再加一个任务同上也会创建一个临时线程

再加一个任务，此时临时线程也用完，就会报错

        //关闭线程池，一般不会使用
        pool.shutdownNow();//有任务也关闭
        //pool.shutdown();//有任务要先将任务跑完再关闭

 

6.4 Executors工具类实现线程池

    public static void main(String[] args) {
        //固定线程个数
        ExecutorService pool = Executors.newFixedThreadPool(3);

        pool.execute(new MyRunnable());
        pool.execute(new MyRunnable());
        pool.execute(new MyRunnable());
        pool.execute(new MyRunnable());//已经没有多余线程了
    }

 

 

 

7 定时器

定时器

  • 定时器是一种控制任务延时调用，或者周期调用的技术。
  • 作用:闹钟、定时邮件发送。

定时器的实现方式

  • 方式一: Timer
  • 方式二: ScheduledExecutorService
     

 

package com.itzw.d8_timer;

import java.util.Date;
import java.util.Timer;
import java.util.TimerTask;

public class TimerDemo01 {
    public static void main(String[] args) {
        //创建timer定时器
        Timer timer = new Timer();
        //调用方法，处理定时任务
        timer.schedule(new TimerTask() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName()+"执行一次AAA "+new Date());
                try {
                    Thread.sleep(10000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },0,2000);

        timer.schedule(new TimerTask() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName()+"执行一次BBB "+new Date());
            }
        },0,2000);
    }
}


package com.itzw.d8_timer;

import java.util.Date;
import java.util.TimerTask;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;

public class TimerDemo02 {
    public static void main(String[] args) {
        ScheduledExecutorService pool = Executors.newScheduledThreadPool(3);

        pool.scheduleAtFixedRate(new TimerTask() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName()+"执行一次AAA-->"+new Date());
                try {
                    Thread.sleep(10000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },0,2, TimeUnit.SECONDS);

        pool.scheduleAtFixedRate(new TimerTask() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName()+"执行一次BBB-->"+new Date());
                System.out.println(10/0);
            }
        },0,2, TimeUnit.SECONDS);

        pool.scheduleAtFixedRate(new TimerTask() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName()+"执行一次CCC-->"+new Date());
            }
        },0,2, TimeUnit.SECONDS);
    }
}

 

8 并发与并行

并发与并行

  • 正在运行的程序(软件)就是一一个独立的进程，线程是属于进程的，多个线程其实是并发与并行同时进行的。

并发的理解:

  • CPU同时处理线程的数量有限。
  • CPU会轮询为 系统的每个线程服务，由于CPU切换的速度很快，给我们的感觉这些线程在同时执行，这就是并发。
     

并行的理解:

  • 在同一个时刻上，同时有多个线程在被CPU处理并执行。

 

 

JavaSE基础学习——多线程
weixin_44018911的博客
04-22 160
1. 多线程的创建 1.1 方式一：继承Thread类 定义一个子类MyThread继承线程类java.lang.Thread，重写run()方法 创建MyThread类的对象 调用线程对象的start()方法启动线程（启动后还是执行run方法的） /** 目标：多线程的创建方式一：继承Thread类实现 */ public class ThreadDemo1 { public static void main(String[] args) { // 3、new一个新线
【Java学习】线程（Thread）
m0_49831249的博客
07-16 356
多线程指两个或多个事件在同⼀个时间段内发⽣（同时发⽣）。
java多线程学习（超详细吐血总结）
热门推荐
chenruijia170707的博客
11-11 2万+
声明：原文出处http://www.cnblogs.com/nsw2018/p/5822270.html，本人出于学习，收集干货，不作商业用途！以下原作者为林炳文Evankaka的原创作品。转载出处：http://blog.youkuaiyun.com/evankakahttp://blog.youkuaiyun.com/evankaka/article/details/44153709#t1  （java线程学习的入门...
Java 并发编程解析 | 如何正确理解Java领域中的多线程模型，主要用来解决什么问题？
m0_73311735的博客
08-18 322
Java领域中的线程主要分为Java层线程(Java Thread) ,JVM层线程(JVM Thread),操作系统层线程(Kernel Thread)。对于Java领域中，从一定程度上来说，由于Java程序并不直接运行在Linux系统上，而是运行在JVM(Java 虚拟机)上，而一个JVM实例是一个Linux进程，每一个JVM都是一个独立的“沙盒”，JVM之间相互独立，互不通信。......
java 临时类_java匿名类的定义
weixin_29741447的博客
02-13 824
匿名类1. 匿名类是一种定义于方法中的内部类 。public class Test {public static void main(String[] args) {Person boy=new Person(){public void eat(){System.out.println(" a boy is eating rice");}};}}定义在 main方法中2.** 匿名类定义在 匿名类...
java - juc - 多线程 - 学习 -思维导图
最新发布
12-16
java - juc - 多线程 - 学习 -思维导图
Java Socket学习---单线程阻塞
06-01
"Java Socket学习---单线程阻塞"这个主题主要探讨了如何使用Java的Socket类进行单线程的阻塞式通信，这种模式通常用于简单的客户端-服务器应用。在这个场景中，服务器端通过一个线程处理一个客户端的请求，当请求被...
Java 实例 - 线程挂起源代码+详细指导教程.zip
08-10
此外，学习线程挂起不仅限于基本方法的使用，还应关注如何避免死锁、饥饿和优先级反转等问题。理解线程的生命周期、状态转换（新建、就绪、运行、阻塞、死亡）以及线程池的概念也是至关重要的。 总之，理解和掌握...
Java 实例 - 线程优先级设置源代码+详细指导教程.zip
08-10
在学习Java线程优先级时，建议你结合提供的源代码进行实践，理解每个线程如何根据其优先级被调度和执行。同时，了解操作系统的线程调度策略也对理解Java线程优先级的工作方式至关重要。 在课程资源中，你可能还会...
java-java面试题库整理-基础-JVM-线程并发-框架等.zip
02-06
为了在激烈的Java开发者竞争中脱颖而出，深入理解Java基础知识、JVM（Java虚拟机）、线程并发以及常用框架是至关重要的。这份"java-java面试题库整理-基础-JVM-线程并发-框架等.zip"文件提供了一个全面的复习资源，...
Java——多线程
m0_48936146的博客
05-16 1283
1、继承Thread类创建多线程 1.1 在学习多线程之前，先来看看单线程程序。 class Mythread{ public void run(){ for(int i=1;i<100;i++){ System.out.println("MyThread类的run()方法在运行"); i+=1; } } } public class Example01 { public static voi
Java笔记-多线程相关
IT1995的博客
12-27 4944
ava多线程和C++里面的多线程有些地方不一样。 毕竟套了一个java虚拟机。对此记录下。 Java语言内置多线程支持： 一个java程序实际上是一个JVM进程。 JVM用一个主线程来执行main()方法。 在main()方法中又可以启动多个进程。 Java多线程创建MyThread类逻辑： 1.从Thread派生； 2.覆写run...
浅谈Java线程
04-27 1435
100亿的值，如果在4核的CPU上利用4个线程执行，线程A计算[1，25亿)，线程B计算[25亿，50亿)，线程C计算[50，75亿)，线程D计算[75亿，100亿]，之后汇总，那么理论上应该比一个线程计算[1，100亿]快将近4倍，响应时间能够降到25%。其中的join()是一种线程同步方法，例如有一个线程对象thread A，当调用A.join()的时候，执行这条语句的线程会等待thread A执行完，而等待中的这个线程，其状态会从RUNNABLE转换到WAITING。因为利用多核可以降低响应时间。
实现多线程
qq_43053169的博客
11-20 182
1.实现多线程 1.1进程 进程 ：是正在运行的程序 是系统进行资源分配和调用的独立单位 每一个线程都有它自己的内存空间和系统资源 1.2 线程 线程：是进程中的单个顺序控制流，是一条执行路径 单线程：一个程序如果只有一条执行路径，则称为单线程程序 多线程：一个程序如果有多条执行路径，则称为多线程程序 1.3多线程的实现方式 方式1：继承Threa类 1.定义一个类MyThread继承T...
多线程批量导入mysql
m0_61344579的博客
04-20 665
【代码】多线程批量导入mysql。
【多线程】初步认识Thread类及其应用
acm_pn的博客
08-18 1022
操作系统针对多个线程的执行，是一个“随机调度”，抢占式执行的过程。线程的调度执行是随机的，我们无法确定两个线程的调度顺序，但是可以控制谁先结束谁后结束。 线程等待就是确定两个线程的结束顺序，通过让后结束的线程等待先结束的线程执行，进入阻塞状态，直到先结束的线程执行完毕，此时阻塞解除，后结束的线程开始执行。这样就能使两个线程的结束顺序得以确定
多线程学习之多线程的三种实现方式及应用
m0_62314761的博客
08-25 290
1.1方法1.2实现步骤定义一个类MyThread继承Thread类在MyThread类中重写run()方法创建MyThread类的对象启动线程1.3代码实例实现一个MyThread类继承Thread，然后重写里面的run()方法。至于说为什么需要重写run()方法是因为run()是用来封装被线程执行的代码。
Java 进阶多线程(一)
java_lujj的博客
09-06 171
调用run方法会当成普通方法执行，只有调用start方法才是启动一个新的线程执行。但是代码要高度面向对象。线程任务对象交给Thread处理，调用start()方法启动线程,执行任务。每次只能一个线程进入，执行完毕后自动解锁，其它线程才可以进来执行。每次只能一个线程进入，执行完毕后自动解锁，其它线程才可以进来执行。是单继承，线程类继承Thread后，不能继承其他类，不便于扩展。线程任务类只是实现接口，可以继续继承类和实现接口，扩展性强。2、这个方法是在哪个线程执行中调用的，就会得到哪个线程对象。
python 写一个Mythread能返回线程执行的结果
windblew的博客
12-01 2205
class MyThread(threading.Thread): def __init__(self,func,args=()): super(MyThread,self).__init__() self.func = func self.args = args def run(self): self.result = self.func(*self.args) def
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值