多线程概况

最新推荐文章于 2024-08-10 22:20:39 发布
最新推荐文章于 2024-08-10 22:20:39 发布
阅读量111 收藏
点赞数
文章标签： java 多线程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/gsylove/article/details/120162478
版权

多线程

核心概念

  1. 线程就是独立的执行路径，而进程是一个动态的概念，进程相当于是多个线程的保护伞

  2. 在程序运行时，及时没有自己创建的线程，后台也会有多个线程，如主线程，gc线程

  3. main()称之为主线程，系统的入口，用于执行整个程序

  4. 多线程之间的顺序是不能人为干预的

  5. 对于同一份资源的操作，可能会有争抢，所以要加入并发控制（让所有人排队）

  6. 线程会带来额外的开销（cpu调度时间，并发控制开销）

  7. 线程中的数据一定要同步

创建线程

方式一

  1. 继承Thread类 （不怎么使用：避免oop单继承局限性）

  2. 重写run()方法，编写线程体

  3. 创建一个线程对象

  4. 调用start开启线程

public class TestThread1 extends Thread {   //1
    @Override     //2
    public void run() {
        //run 线程体
        for (int i = 0; i < 200; i++) {
            System.out.println("执行Run线程"+i);
        }
    }
​
    public static void main(String[] args) {
        //main 线程体
        TestThread1 testThread1 = new TestThread1();  //3
​
        testThread1.start();  //4
​
        for (int i = 0; i < 200; i++) {
            System.out.println("执行Main线程"+i);
        }
    }
}
//两个方法交替执行

注意：线程开启不一定会立即执行，会由CPU来调度

方式二

  1. implements 实现Runnable接口 （用得多：灵活方便，方便同一个对象被多个线程使用）

  2. 实现run()方法，编写线程执行体

  3. 先创建实现类对象

  4. 再创建线程对象（把实现类对象放进去），调用start()方法启动线程

public class TestThread2 implements Runnable {  //1
    @Override
    public void run() {    //2
        //run线程
        for (int i = 0; i < 200; i++) {
            System.out.println("执行run线程"+i);
        }
    }
​
    public static void main(String[] args) {
        //main线程
        TestThread2 testThread2 = new TestThread2(); //3
        Thread thread = new Thread(testThread2);   //4
        thread.start();
​
        for (int i = 0; i < 200; i++) {
            System.out.println("执行main线程"+i);
        }
    }
}

多个线程操作同一个对象

买火车票

public class TestThread3 implements Runnable {
​
    private int tikect = 10;
    @Override
    public void run() {
        while (true) {
            if (tikect<=0) {
                break;
            }
            System.out.println(Thread.currentThread().getName()+"拿到第"+tikect--+ "张票");
        }
    }
​
    public static void main(String[] args) {
        TestThread3 tk = new TestThread3();
        //多个线程操作一个对象
        Thread t1 = new Thread(tk,"小明");  
        Thread t2 = new Thread(tk,"小花");
        Thread t3 = new Thread(tk,"小郭");
        t1.start();
        t2.start();
        t3.start();
​
    }
}

发现问题：多个线程操作同一个资源的时候，线程不安全，数据紊乱

解决：队列 + 🔒

静态代理

好处：代理对象可以做很多真实对象做不了的事情

真实对象专注做自己的事情

public class StaticProxy {
    public static void main(String[] args) {
//        You you = new You();
//        you.happyMarry();
​
        Wedding wedding = new Wedding(new You());
        wedding.happyMarry();
    }
}
interface Marry{
    void happyMarry();
}
class You implements Marry{
​
    @Override
    public void happyMarry() {
        System.out.println("结婚啦");
    }
}
class Wedding implements Marry{
    private Marry target;
​
    public Wedding(Marry target) {  //通过构造方法把真实对象传进去
        this.target = target;
    }
​
    @Override
    public void happyMarry() {
        before();   //代理对象额外能做的事情
        this.target.happyMarry();   //真实对象专心做自己的事情
        after();    //代理对象额外能做的事情
    }
​
    private void after() {
        System.out.println("结婚后的准备");
    }
​
    private void before() {
        System.out.println("结婚前的准备");
    }
}

总结：真实对象和代理对象都要实现同一个接口

代理对象要代理真是角色 (构造方法传入)

Thread 实现 Runnable是一个道理~

Lambda 表达式

最大的大前提:接口为函数式接口，一个接口里面只写了一个函数

目的：

  1. 避免匿名内部类定义过多

  2. 可以让代码看起来更简洁

  3. 去掉很多没有意义的代码

演变过程：外部实现类-->静态内部类-->局部内部类-->匿名内部类（没有类名，并且方法名字都是一样的所以直接去掉）-->Lambda

public class TestLambda1 {
    //3.静态内部类
    static class Love1 implements Ilove{
​
        @Override
        public void iLove(int a) {
            System.out.println("I Love YOU--->"+a);
        }
    }
​
    public static void main(String[] args) {
        //4.局部内部类
        class Love2 implements Ilove{
​
            @Override
            public void iLove(int a) {
                System.out.println("I Love YOU--->"+a);
            }
        }
        Ilove love = new Love();
        love.iLove(2);
​
        love = new Love1();
        love.iLove(3);
​
        love = new Love2();
        love.iLove(4);
​
​
​
​
        //5.匿名内部类
        Ilove ilove = new Ilove(){
            @Override
            public void iLove(int a) {
                System.out.println("I Love YOU--->"+a);
            }
        };
        ilove.iLove(5);
    }
​
​
​
}
//1.接口类
interface Ilove{
    void iLove(int a);
}
//2.外部实现类
class Love implements Ilove{
    @Override
    public void iLove(int a) {
        System.out.println("I Love YOU--->"+a);
    }
}

Lambda简化：

//6.Lambda简化
        ilove = (int a)-> {
            System.out.println("I Love YOU--->"+a);
        };
        ilove.iLove(6);

Lambda简化终极爆炸版:

前提:只能有一行表达式，多行还是需要用花括号包括起来

多个参数也可以去掉参数类型，要去掉都去掉，必须加上括号，用逗号隔开

ilove = a->System.out.println("I Love YOU--->"+a);
ilove.iLove(6);

停止线程

推荐线程自己停下来：

怎么做呢：使用一个标志位进行终止变量，当flag=false，则终止。

public class TestStop implements Runnable {
    private boolean flag = true;
    @Override
    public void run() {
        int i = 0;
        while (flag) {
            System.out.println("run........Thread"+i++);
        }
    }
​
    public static void main(String[] args) {
        TestStop testStop = new TestStop();
        new Thread(testStop).start();
        for (int i = 0; i < 200; i++) {
            System.out.println("main........thread"+i);
            if (i==150) {
                testStop.stop();
                System.out.println("该线程停止了");
            }
        }
    }
    public void stop(){
        this.flag = false;
    }
}

线程休眠

  • sleep指定当前线程阻塞的毫秒数：1000->1s

  • sleep存在异常InterruptedException

  • sleep时间打倒后线程进入就绪状态

  • sleep可以模拟网络延时，倒计时等

  • 每一个对象都有一个🔒，sleep不会释放锁

模拟倒计时

public class TestSleep implements Runnable {
    @Override
    public void run() {
        int num = 10;
        while (true) {
            try {
                Thread.sleep(1000);
                System.out.println("倒计时"+num--);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            if (num<=0) {
                break;
            }
        }
    }
​
    public static void main(String[] args) {
        TestSleep testSleep = new TestSleep();
        new Thread(testSleep).start();
    }
​
}

模拟时钟

public class TestSleep implements Runnable {
    @Override
    public void run() {
        Date startTime = new Date(System.currentTimeMillis());
        while (true) {
            try {
                Thread.sleep(1000);
                System.out.println(new SimpleDateFormat("HH:mm:ss").format(startTime));
                startTime = new Date(System.currentTimeMillis());
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
​
    public static void main(String[] args) {
        TestSleep testSleep = new TestSleep();
        new Thread(testSleep).start();
    }
}

线程礼让

礼让不一定成功，礼让后线程之间重新竞争，CPU还是老大哥

Thread.yield

线程强制执行（插队）

天龙人地位高，我走完了你才能走.....

public class TestJoin implements Runnable{
    @Override
    public void run() {
        for (int i = 0; i < 1000; i++) {
            System.out.println("VIP"+i);
        }
    }
​
    public static void main(String[] args) throws InterruptedException {
        TestJoin testJoin = new TestJoin();
        Thread thread = new Thread(testJoin);
        thread.start();
        for (int i = 0; i < 500; i++) {
            if (i==10) {
                thread.join();
            }
            System.out.println("main"+i);
        }
    }
}

守护线程

God bless you my man~！

  • 线程分为用户线程和守护线程

  • 虚拟机必须确保用户线程执行完毕

  • 不用等守护线程执行完毕

GC线程 记录操作日志 监控内存都是守护线程

public class TestDaemon  {
    public static void main(String[] args) {
        We we = new We();
        Thread thread = new Thread(we);
        God god = new God();
        Thread thread1 = new Thread(god);
        thread1.setDaemon(true); //默认false为用户线程 ， true为守护线程
​
        thread.start();
        thread1.start();
    }
}
class We implements Runnable{
​
    @Override
    public void run() {
        for (int i = 0; i < 365; i++) {
            System.out.println("我还活着！！"+i);
        }
        System.out.println("上票");
    }
}
class God implements Runnable{
​
    @Override
    public void run() {
        while (true) {
            System.out.println("God bless you my man~");
        }
    }
}

synchronized

  • 在方法上修饰的时候可以给这个方法上锁，不同线程访问这个方法就要看是否有锁

  • 用同步块:synchronized(Obj){}来🔒的话 关键在于这个Obj是什么

  • Obj是需要增删改的对象

    同步方法，同步代码块

public class UnSafeBuyTicket implements Runnable{
    private boolean flag = true;
    private int ticket = 10;
    @Override
    public void run() {
        //买票
        while (flag) {
            try {
                buy();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
​
    private synchronized void buy() throws InterruptedException {
        //判断是否有票
        if (ticket<=0) {
            flag = false;
            return;
        }
        //模拟延时
        Thread.sleep(100);
        //买票
        System.out.println(Thread.currentThread().getName()+"买到第"+ticket--+"张票");
    }
​
    public static void main(String[] args) {
        UnSafeBuyTicket unSafeBuyTicket = new UnSafeBuyTicket();
        new Thread(unSafeBuyTicket,"小明").start();
        new Thread(unSafeBuyTicket,"小花").start();
    }
}

死锁

产生的四个必要条件：

  • 互斥条件：一个资源每次只能被一个进程使用

  • 请求与保持条件：一个进程因请求资源而阻塞时，队以获得的资源保持不放

  • 不剥夺条件：进程以获得的资源，在没有使用完的时候，不能被强制剥夺

  • 循环等待条件：进程之间首尾相接循环等待资源

public class DeadLock {
    public static void main(String[] args) {
        MakeUp m1 = new MakeUp("小花", 0);
        MakeUp m2 = new MakeUp("小红", 2);
        m1.start();
        m2.start();
    }
}
//口红
class Lipstick {
}
//镜子
class Mirror {
}
​
class MakeUp extends Thread {
    String girlName;
    int choice;
    private static Lipstick lipstick = new Lipstick();
    private static Mirror mirror = new Mirror();
​
    public MakeUp(String girlName, int choice) {
        this.girlName = girlName;
        this.choice = choice;
    }
    @Override
    public void run() {
        //化妆
        try {
            makeup();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
    private void makeup() throws InterruptedException {
        if (choice==0) {
            synchronized (lipstick){
                System.out.println(this.girlName+"拿到口红");
                Thread.sleep(1000);
                synchronized (mirror){
                    System.out.println(this.girlName+"拿到镜子");
                }
            }
        }else{
            synchronized (mirror){
                System.out.println(this.girlName+"拿到镜子");
                Thread.sleep(2000);
                synchronized (lipstick){
                    System.out.println(this.girlName+"拿到口红");
                }
            }
        }
    }
}

解决：用完了释放🔒

public class DeadLock {
    public static void main(String[] args) {
        MakeUp m1 = new MakeUp("小花", 0);
        MakeUp m2 = new MakeUp("小红", 2);
        m1.start();
        m2.start();
    }
}
//口红
class Lipstick {
}
//镜子
class Mirror {
}
​
class MakeUp extends Thread {
    String girlName;
    int choice;
    private static Lipstick lipstick = new Lipstick();
    private static Mirror mirror = new Mirror();
​
    public MakeUp(String girlName, int choice) {
        this.girlName = girlName;
        this.choice = choice;
    }
    @Override
    public void run() {
        //化妆
        try {
            makeup();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
    private void makeup() throws InterruptedException {
        if (choice==0) {
            synchronized (lipstick){
                System.out.println(this.girlName+"拿到口红");
                Thread.sleep(1000);
            }
            synchronized (mirror){
                System.out.println(this.girlName+"拿到镜子");
            }
        }else{
            synchronized (mirror){
                System.out.println(this.girlName+"拿到镜子");
                Thread.sleep(2000);
            }
            synchronized (lipstick){
                System.out.println(this.girlName+"拿到口红");
            }
        }
    }
}

为了更好的控制多个线程对共享资源进行访问--->产生了一个工具类！它就是Lock！！当当当~~

java.util.concurrent.locks.Lock  //接口

ReentrantLock 类实现了Lock -->更加常用 可重入锁

因为加锁之后最后都要释放锁

所以一般都与try finally一起用

快捷键： crtl +alt +t

public class TestLock {
    public static void main(String[] args) {
        TestLock2 testLock2 = new TestLock2();
        new Thread(testLock2).start();
        new Thread(testLock2).start();
        new Thread(testLock2).start();
    }
}
​
class TestLock2 implements Runnable{
    private int ticket = 10;
​
    //定义Lock
    private final ReentrantLock lock = new ReentrantLock();  //这一句很重要
    @Override
    public void run() {
        while (true) {
            try {
                lock.lock();    //显示的加锁
                if (ticket>0) {
                    System.out.println(ticket--);
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            } finally {
                lock.unlock();   //显示的释放锁
            }
        }
    }
}

synchronized 与Lock 的对比

  • Lock时显示🔒 （手动挡）synchronized是隐式🔒，除了作用域自动释放(自动挡)

  • synchronized 比 Lock 多了一个方法🔒

  • 使用Lock🔒，JVM花费时间少些，性能更好，并且具有更好的发展性(提高更多的子类)

  • 优先使用顺序：

    • Lock > 同步代码块 > 同步方法

线程通信

wait(): 表示线程一直等待，直到其他线程通知，与Sleep不同，wait会释放锁
notify(): 唤醒处于等待中的线程
notifyAll(): 唤醒同一对象上所有调用wait()方法的线程，优先级别高的的线程优先调度

注意:均是Object类的方法，都只能再同步方法或者同步代码块中使用，否则会抛出异常

illegalMonitorStateException

生产者与消费者

public class TestPC {
    public static void main(String[] args) {
        SynContainer container = new SynContainer();
        Productor productor = new Productor(container);
        Consumer consumer = new Consumer(container);
        productor.start();
        consumer.start();
    }
}
​
//生产者
class Productor extends Thread {
    SynContainer container;
​
    public Productor(SynContainer container) {
        this.container = container;
    }
​
    //生产
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.println("生产了" + i + "只鸡");
            container.push(new Chicken(i));
        }
    }
}
//消费者
class Consumer extends Thread {
    SynContainer container;
​
    public Consumer(SynContainer container) {
        this.container = container;
    }
​
    @Override
    public void run() {
        //消费
        for (int i = 0; i < 100; i++) {
            System.out.println("消费了"+container.pop().id+"只鸡");
        }
    }
}
​
//缓冲区
class SynContainer {
    //放鸡的容器
    Chicken[] chickens = new Chicken[10];
​
    //记录容器里面鸡的数量
    int count = 0;
​
    //生产者生产鸡
    public synchronized void push(Chicken chicken){
        //容器满了
        if (count==chickens.length) {
            //通知消费者消费
        }
        //没满就往容器里面放
        chickens[count] = chicken;
        count++;
    }
​
    //消费者消费
    public synchronized Chicken pop(){
        //判断能否消费
        if (count==0) {
            //通知生产者生产
        }
        Chicken chicken = chickens[count];
        count--;
​
        return chicken;
    }
}
//产品
class Chicken{
    int id;
​
    public Chicken(int id) {
        this.id = id;
    }
}
public class TestPC2 {
    public static void main(String[] args) {
        Tv tv = new Tv();
        new Player(tv).start();
        new Watcher(tv).start();
    }
}
​
class Player extends Thread{
    Tv tv;
​
    public Player(Tv tv) {
        this.tv = tv;
    }
​
    @Override
    public void run() {
        for (int i = 0; i < 20; i++) {
            if (i%2==0) {
                this.tv.play("快乐大本营播放中");
            }else {
                this.tv.play("抖音播放");
            }
        }
    }
}
class Watcher extends Thread {
    Tv tv;
​
    public Watcher(Tv tv) {
        this.tv = tv;
    }
    @Override
    public void run() {
        for (int i = 0; i < 20; i++) {
            this.tv.watch();
        }
    }
}
class Tv{
    //演员演出 观众等待
    //演出结束 观众观看
    String voice; //节目
    boolean flag=true;
​
    //表演
    public synchronized void play(String voice){
        if (!flag) {
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        System.out.println("表演了"+voice);
​
        //通知观众看
        this.notifyAll();
        this.voice=voice;
        this.flag=!this.flag;
    }
​
    //观看
    public synchronized void watch(){
        if (flag) {
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        System.out.println("观看了"+voice);
​
        //通知演员表演
        this.notifyAll();
        this.flag=!this.flag;
    }
}
​
gsylove
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
OpenMP多线程编程及性能优化
07-19
##### 1.1 OpenMP多线程编程发展概况 OpenMP是一种专为共享内存架构设计的多线程并行编程语言和技术标准，它允许程序员通过简单的编译指令来指导编译器自动并行化代码。这一标准由Silicon Graphics Inc. (SGI)发起...
多线程断点续传软件的设计与实现
11-29
### 多线程断点续传软件的设计与实现 #### 1. 课题背景与意义 在当前互联网时代，下载软件已经成为人们日常生活中不可或缺的一部分。然而，早期的下载功能仅限于从WEB服务器上连续读取文件，一旦连接中断就需要...
基于ARM的多线程应用程序设计.doc
07-02
"基于ARM的多线程应用程序设计" 基于ARM的多线程应用程序设计是计算机科学中重要的研究方向， ARM 架构是目前最流行的嵌入式系统处理器架构之一，多线程应用程序设计是提高系统性能和效率的关键技术之一。本文档对...
基于ARM的多线程应用程序的设计73351.doc
10-04
基于ARM架构的多线程应用程序设计主要涉及到操作系统中的并发执行和线程同步机制。生产者-消费者问题是多线程编程中的一个经典案例，它展示了如何在多个线程间共享资源并确保数据的一致性和正确性。在这个问题中，有...
GPU概况survey
03-23
而GPU则包含数百甚至数千个小核心，擅长执行SIMD（单指令多数据）或SIMT（单指令多线程）操作，能同时处理大量相同或相似的任务，非常适合进行大规模并行计算。 GPU的工作流程一般包括：从CPU接收数据，然后在GPU...
C++ - 函数重载
jiaowenjie的专栏
08-06 317
/打印的是第二个函数的地址。//打印的是第一个函数的地址。-> 重载函数在本质上是相互独立的不同函数。-> 函数返回值不能作为函数重载的依据。-> 重载函数的函数类型不同。**3.函数默认参数和函数重载****函数重载的注意事项：****4.函数重载的本质**
Spring事务
c1tenj2的博客
08-07 429
以银行转账为例，一次转账操作伴随着一个账户的扣钱和另一个账户的加钱，这个流程是一个原子操作，要么同时发生，一气呵成，要么都不做。AccountServiceImpl实现AccountService接口，里面只有一个转账方法AccountMapper以及其映射文件account数据库测试代码用1/0模拟程序运行时出现异常的情况由于没有开启事务，出现了莫名其妙少了100块钱的情况，说明这个事务不是连续的。
反射和注解
supercool7的博客
08-08 228
反射的基本步骤包括获取Class对象、获取类的信息（构造函数、方法、字段等），然后通过Constructor、Method、Field等类的实例进行具体的操作。注解以@符号开头，通常紧跟着一个标识符，后面可以跟一些参数，用于给类、方法、字段等添加元数据信息，这些信息可以在编译时、运行时被读取和处理。通过Class类，可以获取类的构造函数、方法、字段等信息，而不需要在编译时确定这些信息。Spring、SpringBoot、Mybatis等框架中都大量使用了反射机制。此外，开发者还可以定义自己的注解，通过。
Java：继承，this，super
m0_75257168的博客
08-10 208
可以同名，但参数列表不能相同（有参无参构造）
安卓Android & JAVA校招/实习面试合集:多线程、强软弱虚引用、进程、内存管理、Activity、Fragment......
qq_41915623的博客
08-10 253
安卓Android、java面试资料合集：内存管理、多线程、进程、强软弱虚应用、Activity
JVM 加载阶段 Class对象加载位置是在 堆中还是方法区？
萧曳丶
08-06 356
Class对象的加载位置：Class对象本身是加载到堆区中的。类的类型信息加载位置：类的类型信息（元数据）是加载到方法区（或元空间）中的。因此，对于问题“jvm 加载阶段 Class加载到堆中还是方法区”，答案是：Class对象加载到堆中，而类的类型信息加载到方法区（或元空间）中。这两个区域在JVM的类加载过程中都扮演着重要的角色，共同支持着Java程序的运行。
Java | Leetcode Java题解之第324题摆动排序II
m0_57195758的博客
08-06 335
Java | Leetcode Java题解之第324题摆动排序II
Spring一个强大便捷的代理工厂类
330553352的专栏
08-10 188
但如果你需要一种更加灵活和可配置性，那么Spring还提供了一个非常方便强大的ProxyFactoryBean类，该类特别适合那些需要更多自定义和控制的场景，例如当你需要为特定的Bean创建代理，或者需要在不修改原始代码的情况下为现有类添加额外的功能时。在Spring框架中，AOP（面向切面编程）是一种强大的编程范式，它允许开发者在不修改原有代码的情况下，为程序添加额外的功能，如日志记录、事务管理、安全控制等。在上面配置拦截器时，我们都是指定的具体拦截器，其实我们还可以使用通配符，指定拦截器。
dynamic-datasource+Mybatis多数据源使用
tiantiantbtb的博客
08-06 887
严格匹配数据源,默认false. true未匹配到指定数据源时抛异常,false使用默认数据源。#设置默认的数据源或者数据源组,默认值即为master。#去掉默认使用HikariCP。
javaImageIo实现图片内容动态修改
zhangzeshan
08-07 157
在指定坐标绘制水印文字
Leetcode JAVA刷刷站（10）正则表达式匹配
m0_73399576的博客
08-10 474
Leetcode JAVA刷刷站——字符串转换整数篇
MTK Android12 关机界面全屏展示
十年饮冰，难凉热血
08-08 732
实现点击关机【重启一样的逻辑】，弹出一个界面的需求，实现方式：1）去掉关机、重启的dialog的 dismiss方法，mDialog.dismiss();【也可以不去，全屏界面会盖住】2）在关闭实现全屏界面，这里用全屏dialog 实现。
mvn install:install-file命令
Simon_cm的博客
08-07 118
包路径,groupId,artifactId,版本,需要加英文"",否则可能会报错。-DgeneratePom=true：是否自动生成POM文件，默认为true。-DcreateChecksum=true：是否创建校验和文件，默认为true。-Dpackaging：打包方式，通常是 jar,war等。-DartifactId：通常是项目的构件id。-DgroupId：通常是项目的组id。-Dfile：要引入的jar包路径。-Dversion：版本。
Day22--IO流知识简学
最新发布
gitee_nanzhi66的博客
08-10 597
Java的I/O流为我们提供了强大的数据处理能力。通过合理选择和使用不同类型的流对象，我们可以高效地进行数据传输和处理。理解流的概念和分类，将帮助我们在开发中更好地应对不同的I/O需求。
多线程(Timer定时器)的重点概况
07-12
多线程编程中使用Timer定时器的重点可以概括如下： 1. 创建Timer对象：创建一个Timer对象，可以使用Timer类的构造方法来实现。 2. 定义TimerTask：TimerTask是一个抽象类，需要继承它并实现run()方法，用于定义需要定时执行的任务逻辑。 3. 安排定时任务：使用Timer对象的schedule()方法来安排定时任务。该方法接受一个TimerTask对象和延迟时间作为参数，可以选择设置定时任务的执行周期。 4. 取消定时任务：如果需要取消已安排的定时任务，可以调用Timer对象的cancel()方法来完成。 5. 异常处理：在使用Timer定时器时，需要注意异常处理。在run()方法中捕获可能抛出的异常，并进行适当的处理。 6. 线程安全：Timer是单线程的，即所有定时任务都在同一个线程中执行。如果一个定时任务的执行时间过长，可能会影响其他任务的执行。为避免这种情况，可以考虑使用ScheduledExecutorService类来实现多线程定时任务。 总之，Timer定时器是Java多线程编程中常用的工具之一，用于实现简单的定时任务调度。在使用Timer定时器时，需要注意线程安全、异常处理和任务取消等问题，以确保定时任务的准确性和稳定性。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值