java—13 多线程

最新推荐文章于 2024-08-24 22:01:16 发布
最新推荐文章于 2024-08-24 22:01:16 发布
阅读量101 收藏
点赞数
分类专栏： java学习 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/rookie_0_0/article/details/113862705
版权

一、创建线程

1、继承Thread类

  • 子类覆写父类中的run方法
  • 建立子类对象的同时线程也被创建
  • 调用start () 开启线程
public class Test {
    public static void main(String[] args) {
    2、建立子类对象
    Pop p = new Pop();
    
    3、开启线程
    p.start();
        for (int i = 0; i < 20; i++) {
            System.out.println("main" + i);
        }
    }
}
class Pop extends Thread {  
    1、重写父类中的run方法
    public void run(){
        for (int i = 0; i <10 ; i++) {
            System.out.println("chi"+ i);
        }
    }
}

弊端：继承是单继承，不能实现多继承，因此使用 Runnable 接口来实现多继承

2、Runnable接口

  • 子类覆盖接口中的run方法
  • 通过Thread类创建线程，并将实现了Runnable接口的子类对象作为参数传递给Thread类的构造函数
  • Thread类对象调用start方法开启线程
  • 可使用匿名内部类来写
public class Test {
    public static void main(String[] args) {
        //1.创建一个Runnable接口的实现类对象
        Pop p = new Pop();
        //2.创建Thread类对象，构造方法中传递Runnable接口的实现类对象
        Thread t = new Thread(p);
        //3.调用Thread类中的start方法，开启新的线程执行run方法
        t.start();
        for (int i = 0; i < 50; i++) {
            System.out.println("main" + i);
        }
    }
}
class Pop implements Runnable {
    @Override
    public void run() {
        for (int i = 0; i < 40; i++) {
            System.out.println("chi" + i);
        }
    }
}

3、匿名内部类实现

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

lambda表达式

public class Test {
    public static void main(String[] args) {
        new Thread(()->{
                for (int i = 0; i <10 ; i++) {
                    System.out.println("nihao");
                }
        }).start();
    }
}

4、 实现Callable接口，重写call方法

比较
通过继承Thread类和实现Runnable接口来创建线程的缺点：
1）没有返回值
2）不支持泛型
3）异常必须处理

因此，使用Callable接口这种方法功能更加强大 ↓

public class Test2 {
    public static void main(String[] args) {
//        计算任务
        Compute c = new Compute();
        /*
        FutureTask同时实现了Runnable，Future接口
        它既可以作为Runnable被线程执行，又可以作为Future得到Callable的返回值
        可以看成FutureTask实现了Runnable接口
        */
        FutureTask<Integer> ft = new FutureTask<>(new Callable<Integer>() {
            @Override
            public Integer call() throws Exception {
                TimeUnit.SECONDS.sleep(10);//10s
                return c.add(1, 1);
            }
        });
        new Thread(ft, "A").start();
        try {
            System.out.println("正在计算结果：");
            System.out.println(ft.get());
            System.out.println("计算完成了吗？"+ft.isDone());
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
    }
}
class Compute {
    public int add(int a, int b) {
        return a + b;
    }
}

当我们卖票的时候，同时有三个售票窗口，相当于三个线程，这时候如果同时卖出第100号票，那就会造成线程不安全问题，如何解决呢？就给CPU抢到的那条线程加上锁，锁住对象，后面的就进不来，直到执行完毕后，将1---->0，锁打开，其他线程继续抢夺执行权，重复操作，保证线程安全。

二、解决线程安全问题

1. 同步代码块

格式：
synchronized (锁对象) { 共享资源 }

public class Test2 {
    public static void main(String[] args) {
        Run p = new Run();
        new Thread(()->{
              p.run();
        },"A").start();
        new Thread(()->{
            p.run();
        },"B").start();
    }
}
-------------------------------------------------------------------------------------
public class Run implements Runnable {
    private int tk = 100;
    @Override
    public void run() {
        while(true){
          paytk();
        }
    }
    public /*synchronized*/ void paytk() {
        synchronized (this) {
            if (tk > 0) {
                try {
                    Thread.sleep(10);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName() + "-->正在卖票第" + tk + "张");
                tk--;
            }
        }
    }
}

2. 同步方法

格式：
synchronized 返回值类型 方法名 （参数列表）{ 共享资源 }

 public synchronized void paytk(){
        if(tk>0){
            try {
                Thread.sleep(10);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName()+"-->正在卖票第"+tk+"张");
            tk--;
        }
    }

3. 静态方法的同步

注意：
静态的锁对象不能是this了，
this是创建对象后产生，
静态方法优先对象,
静态方法的锁对象是本类的class属性

public class Run implements Runnable {
    private static int tk = 100;

    @Override
    public void run() {
        while (true) {
            paytk();
        }
    }
    //静态方法的同步，记得成员变量也要是静态的才行
    public static synchronized void paytk() {
        if (tk > 0) {
            try {
                Thread.sleep(10);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName() + "-->正在卖票第" + tk + "张");
            tk--;
        }
    }

}
-------------------------------------------------------------------------

public static void paytk() {
        synchronized (Run.class) {
            if (tk > 0) {
                try {
                    Thread.sleep(10);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName() + "-->正在卖票第" + tk + "张");
                tk--;
            }
        }
    }

4. Lock 锁

ReentrantLock 与synchronized 区别

ReentrantLock：
	是一个类，可设置。
	构造方法，默认的构造是非公平重入锁(false)，也可以设置为公平锁。
	可以手动释放锁。finally中释放锁。
	可以设置超时时间。
	比如说：A线程持有锁，B线程可以等待一定的时间之后，
	如果得不到锁，就放弃，不会死等。
	看代码执行完了，就会释放锁。
	
synchronized：
	是一个关键字，不可以改变。
	一旦加上锁，不可以中断。
	比如说：A线程持有synchronized锁，那么B线程尝试获得锁，
	拿不到的时候就会进入EntryList中等待。
	这里是看锁标志位改了没有，没改就认为是锁住的。

public class Run implements Runnable {
    private int tk = 100;

    1.在成员属性位置创建一个ReentrantLock对象
   
    Lock lc = new ReentrantLock();

    @Override
    public void run() {
        while (true) {
            
            2.在可能出现安全的代码前面调用lock()
            
            lc.lock();
           
            if (tk > 0) {
                try {
                    Thread.sleep(10);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName() + "-->正在卖票第" + tk + "张");
                tk--;
            }
           
            3.开锁
            lc.unlock();
        }
    }
}

对于开锁，要实现是否有异常出现，都释放掉锁，提高效率，使用 finally子句

  public void run() {
        while (true) {
           
            lc.lock();
            if (tk > 0) {
                try {
                    Thread.sleep(10);
                    System.out.println(Thread.currentThread().getName() + "-->正在卖票第" + tk + "张");
                    tk--;
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } finally {
                    // 3.开锁
                    lc.unlock();
                }
            }
        }
    }

三、等待唤醒 —— wait、notify

注意:

1、wait和notify方法必须是同一个锁对象调用
2、wait和notify方法都是属于Object类中的方法
3、wait和notify方法必须在同步代码块中使用

生产者与消费者问题

public class Test2 {
    public static void main(String[] args) {
        Object obj = new Object();
//       消费者排队领票
        new Thread() {
            @Override
            public void run() {
                while (true) {
                //使用同步保证两个线程只执行一个
                    synchronized (obj) {
                        System.out.println("现在排队领票看'你好，李焕英！'");
//                   调用wait()
                        try {
                            obj.wait();
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
//                   唤醒之后就可以拿票观看了
                        System.out.println("好的，我准备观看了！");
                        System.out.println("----------------------------");
                    }

                }
            }
        }.start();
//       生产者发票
        new Thread() {
            @Override
            public void run() {
                while (true) {
                    try {
                        Thread.sleep(2000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                     //使用同步保证两个线程只执行一个
                    synchronized (obj) {
                        System.out.println("拿好票，可以看电影了");
//                  唤醒消费者可以领票了
                        obj.notify();
                    }
                }
            }
        }.start();
    }
}

在这里插入图片描述

四、Daemon 守护线程

Java线程分为用户线程和守护线程。

守护线程：处于后台运行，任务是为其他线程提供服务，是程序运行的时候在后台提供一种通用服务的线程。JVM的GC回收线程就是守护线程。

特点：当用户线程执行结束，守护线程就会结束。
设置后台线程：Thread对象setDaemon(true);

注意：
1、setDaemon(true)必须在start()调用前，否则出现IllegalThreadStateException异常；
2、用户线程创建的线程默认是用户线程,守护线程创建的线程也是守护线程;
3、判断是否是守护线程：使用Thread对象的isDaemon()方法。

public class Test2 {

    public static void main(String[] args) {
        Thread t1 = new Thread(() -> {
            //判断守护线程创建的线程是否为守护线程？
            Thread t2 = new Thread(() -> {
                try {
                    Thread.sleep(500);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("t2" + (Thread.currentThread().isDaemon() ? "是守护线程" : "不是守护线程"));
            });
            t2.start();

            int i=1;
            while(true) {
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("t1" + (Thread.currentThread().isDaemon() ? "是守护线程," : "不是守护线程,")+"这是第"+i+"次");
//                当用户线程执行结束，守护线程就会结束。
                i++;
                if(i >= 5 ){
                    break;
                }
            } });
            
        t1.setDaemon(true);
        t1.start();

        try {
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("主线程结束了");
    }
}
/*t2是守护线程
t1是守护线程,这是第1次
主线程结束了*/
rookie_0_0
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java多线程编程总结
01-31
要认识多线程就要从操作系统的原理说起。以前古老的DOS操作系统（V6.22）是单任务的，还没有线程的概念，系统在每次只能做一件事情。比如你在copy东西的时候不能rename文件名。为了提高系统的利用效率，采用批处理来...
Java13-多线程编程
qq_37020594的博客
08-31 723
1、多线程基础   进程：每执行一个程序都会在操作系统中建立一个进程。进程是操作系统中管理程序的最小单位。进程可以分为主进程和子进程。当进程中的所有子进程和子线程关闭结束后，进程才会关闭。   线程：线程是进程的组成单位，一个进程可由多个线程组成。线程可分为一个主线程和一个多多个子线程。一般子线程关闭后，子线程仍可执行一段时间。   一个进程只有一个主线程，但可以有多个子线程。   线程资源必须通...
Java进阶13（多线程、线程安全）
么古的博客
04-09 134
Part01:多线程 1、进程和线程的概念 进程：正在运行的程序叫做进程； 线程：是进程中的一个执行单元，来完成进程中的某个功能；一个进程中至少有一个线程； 2、多线程：多线程是指一个进程中有多个线程在同时执行； 3、程序运行原理 分时调度：所有的线程轮流使用CPU的使用权，平均分配每个线程占用CPU的时间 抢占式调度：优先让优先级高的线程使用CPU，如果线程的优先级相同，那么会随机选择一个...
Java多线程详解及示例
07-20
Java多线程编程是提升程序性能和响应性的关键技术。理解多线程的概念，掌握线程的创建、同步、通信、死锁避免等核心知识点，以及合理使用线程池，对于编写高效、稳定的并发程序至关重要。通过实践，开发者可以更好地...
Java多线程下载器
09-26
Java多线程下载器是一种利用Java编程语言实现的高效文件下载工具，它通过将大文件分割成多个部分并同时下载，显著提高了下载速度。在Java中实现多线程下载器涉及许多关键概念和技术，包括线程、并发控制、网络I/O...
JAVA-多线程 所有文件
01-09
这个“JAVA-多线程 所有文件”压缩包很可能包含了一系列关于Java多线程学习的源代码示例和相关文档。下面我们将深入探讨Java多线程的相关知识点。 1. **线程的概念**：线程是操作系统分配CPU时间的基本单位，一个...
java 多线程
11-07
### Java多线程知识点详解 #### 一、Java Thread 概念 在Java中，**线程**是一种轻量级的进程，它是程序执行流的最小单元。一个标准的Java应用通常至少包含一个线程，即主（Main）线程。Java支持多线程编程，这...
阿里云服务器 篇七：服务器热备份/定时备份
最新发布
生活在别处
08-24 59
Python 客户端用于百度云（个人云存储）百度云/百度网盘 Python 客户端。它主要用于在 Linux 环境下通过命令行操作百度云盘的 2TB 存储空间。是一个Github开源项目，这是一个百度云/百度网盘Python客户端。: 列出百度 PCS 中的 ‘remotepath’ 目录。: 从本地目录同步到远程目录。: 在百度云中创建一个目录。
开发多线程程序时，需要注意那些问题
OO_SEN的博客
08-23 500
线程安全 竞态条件（Race Condition）：当多个线程同时访问和修改共享资源时，可能会出现竞态条件，导致不确定的行为。需要通过同步机制（如互斥锁、读写锁、原子操作）来保护共享资源。 死锁（Deadlock）：当两个或多个线程相互等待对方释放锁时，程序会陷入死锁状态。避免死锁的一些策略包括：避免嵌套锁、确保加锁顺序一致、使用超时机制等。 活锁（Livelock）：与死锁不同，活锁是指线程不断地尝试获取资源但总是失败，导致无法继续执行。避免频繁重试操作或使用退避算法可以减少活锁的发生。 优先级反转（P
笔记redis
风止的博客
08-22 1037
Redis（Remote Dictionary Server）是用C语言开发的一个基于的数据库。
linux上datax 安装以及使用
寂夜了无痕的博客
08-24 685
linux上datax 安装以及使用
@Transactional中使用线程锁导致了锁失效与解决方案
liuruiaaa的博客
08-23 568
@Transactional中使用线程锁导致了锁失效与解决方案
android apk 加固后的地图加载异常及重新签名
calivnBao的博客
08-20 262
android apk 加固后的地图加载异常及重新签名
如何使用 Java 记录简化 Spring Data 中的数据实体
08-20 613
Java 开发人员一直依赖Spring Data来实现高效的数据访问。但是，随着Java Records的引入，数据实体的管理方式发生了重大变化。在本文中，我们将讨论 Java Records 在 Spring Data 应用程序中的集成。我们将探讨使用 Java 记录创建健壮的数据实体的好处，并提供真实世界的示例来展示它们在 Spring Data 中的潜力。Java 记录的力量：概述J...
JavaScript 错误 - Throw 和 Try to Catch的使用
逆风优雅的博客
08-23 123
trycatchthrow上面的代码 因为 try中 没有adddlert这个方法，或者这个方法有误，这时，代码会执行catch部分。JavaScript 实际上会创建带有两个属性的Error 对象name和message。
[笔记] hyperf event
BLOCKGOLD.E的博客
08-20 508
得益于组件的支撑，用户可以很方便的对以下事件进行监听。例如。接下来我们就实现一个记录SQL的监听器，来说一下怎么使用。首先我们定义好，实现接口并对类定义php/***//***/return [/***/if (!
使用Java通过身份证号码匹配省市县名称的技术博客
weixin_41489908的博客
08-21 342
每日自动更新各类学习教程及工具下载合集​​在中国，身份证号码包含了持有人的出生地信息。通过解析身份证号码的前六位，我们可以获取对应的省、市、县（区）信息。在这篇博客中，我们将探讨如何使用Java代码来实现这一功能，并展示详细的代码示例和运行结果。
Java中自定义注解的使用
echola_mendes的博客
08-22 984
以【记录操作日志】为例，一般在开发中为了记录用户操作，当系统出现问题时，可以追溯日志所提供详细的错误信息，帮助开发者快速定位问题的原因最简单的方法：在每个方法中增加日志信息打印代码，来记录操作日志，但是这样重复代码也很多，也不易扩展，而且易出错使用自定义注解就会方便很多，减少不必要的重复代码，减少非业务代码的侵入性，如果需要扩展操作用户的信息以及IP就会很方便，易于扩展和维护@interface在需要使用自定义注解的地方使用该注解@LogOperation("新增")// 方法实现。
JavaSE 集合
ALLWE的博客
08-20 676
调用空构造器时初始化 Object[] elementData 数组，长度为10；初始化 size 属性，值为0；当elementData 数组中的10个位置都有元素后，添加第11个元素时数组扩容；扩容长度为原数组的1.5倍；扩容逻辑是创建一个长度为 15 的数组，将旧数组的数据拷贝到新数组中。
Java实现多线程下载工具
"疯狂java实例-第11章_多线程下载工具" 在Java编程领域，多线程下载工具的实现是一项重要的技能，它能够帮助用户高效地管理和下载网络资源。本章节主要聚焦于如何使用Java来开发一个支持HTTP协议的多线程下载工具，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值