Java 多线程

最新推荐文章于 2022-04-20 16:11:11 发布
最新推荐文章于 2022-04-20 16:11:11 发布
阅读量153 收藏
点赞数
文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_45677100/article/details/118611514
版权

Java 多线程

程序 - 进程 - 线程

程序(program)是为完成特定任务、用某种语言编写的一组指令的集合。即指一段静态的代码，静态对象。

进程(process)是程序的一次执行过程，或是正在运行的一个程序。动态过程：有它自身的产生、存在和消亡的过程。

如：运行中的QQ，运行中的MP3播放器

程序是静态的，进程是动态的

线程(thread)，进程可进一步细化为线程，是一个程序内部的一条执行路径。

若一个程序可同一时间执行多个线程，就是支持多线程的

每个Java程序都有一个隐含的主线程： main 方法

多线程程序的优点：

1.提高应用程序的响应。对图形化界面更有意义，可增强用户体验。

2.提高计算机系统CPU的利用率

3.改善程序结构。将既长又复杂的进程分为多个线程，独立运行，利于理解和修改

何时需要多线程

程序需要同时执行两个或多个任务。

程序需要实现一些需要等待的任务时，如用户输入、文件读写操作、网络操作、搜索等。

需要一些后台运行的程序时。

Thread类

Thread类的特性

每个线程都是通过某个特定Thread对象的run()方法来完成操作的，经常把run()方法的主体称为线程体

通过该Thread对象的start()方法来调用这个线程

构造器

Thread()：创建新的Thread对象

Thread(String threadname)：创建线程并指定线程实例名

Thread(Runnable target)：指定创建线程的目标对象，它实现了Runnable接口中的run方法

Thread(Runnable target, String name)：创建新的Thread对象

Thread类的有关方法

void start(): 启动线程，并执行对象的run()方法

run(): 线程在被调度时执行的操作

String getName():返回线程的名称

void setName(String name):设置该线程名称

static currentThread():返回当前线程

static void yield()：线程让步(不一定好用)

暂停当前正在执行的线程，把执行机会让给优先级相同或更高的线程。若队列中没有同优先级的线程，忽略此方法

join() ：当某个程序执行流中调用其他线程的 join() 方法时，调用线程将被阻塞，直到 join() 方法加入的 join 线程执行完为止 ，低优先级的线程也可以获得执行

static void sleep(long millis)：(指定时间:毫秒)

令当前活动线程在指定时间段内放弃对CPU控制,使其他线程有机会被执行,时间到后重排队。抛出InterruptedException异常

stop(): 强制线程生命期结束

boolean isAlive()：返回boolean，判断线程是否还活着

Java的调度方法

同优先级线程组成先进先出队列（先到先服务），使用时间片策略

对高优先级，使用优先调度的抢占式策略

线程的优先级

线程的优先级控制

MAX_PRIORITY（10）;

MIN _PRIORITY （1）;

NORM_PRIORITY （5）;

涉及的方法：

getPriority() ：返回线程优先值

setPriority(int newPriority)：改变线程的优先级

线程创建时继承父线程的优先级

创建线程的两种方式

1.继承Thread类

  1. 定义子类继承Thread类。

  2. 子类中重写Thread类中的run方法。

  3. 创建Thread子类对象，即创建了线程对象。

  4. 调用线程对象start方法：启动线程，调用run方法。

public class ThreadTest {
    public static void main(String[] args) {
        Thread thread=Thread.currentThread();//静态获取当前线程的对象
        System.out.println(thread.getName());//main
        thread.setName("线程");//尽量不要修改主线程的名字
        System.out.println(thread.getName());

        Thread1 thread1 = new Thread1("线程1");
        thread1.setPriority(10);//优先级
        //开启线程用start方法
        thread1.start();

        Thread1 thread2 = new Thread1("线程2");
        thread2.setPriority(1);//优先级
        thread2.start();
        //打印线程的优先级
        System.out.println(thread1.getPriority());
        for(int j=0;j<100;j++) {
            if(j>=20) {
                //thread1.yield();//让步  不一定
                try {
                    thread1.join();//插队
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            //打印线程的优先级 默认为5
            System.out.println(Thread.currentThread().getPriority());
            System.out.println(Thread.currentThread().getName() + "我也运行了" + j);
        }
    }
}

class Thread1 extends Thread{
    public Thread1(String name)
    {
        super(name);
    }
    public void run()
    {
        for (int i=0;i<100;i++)
            System.out.println(Thread.currentThread().getName()+"运行了"+i);
    }
}

2. 实现Runnable接口

1）定义子类，实现Runnable接口。

2）子类中重写Runnable接口中的run方法。

3）通过Thread类含参构造器创建线程对象。

4）将Runnable接口的子类对象作为实际参数传递给

Thread类的构造器中。

5）调用Thread类的start方法：开启线程，调用

Runnable子类接口的run方法。

public class RunnableTest {
    public static void main(String[] args) {
        Runnable1 runnable1 = new Runnable1();
        Thread thread = new Thread(runnable1);
        thread.start();
        /*ExecutorService pool1= Executors.newSingleThreadExecutor();
        //submit   提交
        pool1.submit(new Runnable1());
        //运行
        pool1.execute(new Runnable1());
        //关闭资源
        pool1.shutdown();*/
    }
}

class Runnable1 implements Runnable{

    @Override
    public void run() {
        for(int i=0;i<100;i++)
            System.out.println(Thread.currentThread().getName()+"运行了"+i);
    }
}

继承方式和实现方式的联系与区别

区别

继承Thread: 线程代码存放Thread子类run方法中。

实现Runnable：线程代码存在接口的子类的run方法

实现方法的好处

1）避免了单继承的局限性

2）多个线程可以共享同一个接口子类的对象，非常适合多个相同线程来处理同一份资源。

守护线程

Java中的线程分为两类：一种是守护线程，一种是用户线程。

它们在几乎每个方面都是相同的，唯一的区别是判断JVM何时离开。

守护线程是用来服务用户线程的，通过在start()方法前调用thread.setDaemon(true)可以把一个用户线程变成一个守护线程。

Java垃圾回收就是一个典型的守护线程。

若JVM中都是守护线程，当前JVM将退出。

public class Protect {
    public static void main(String[] args) {
        ProtectPerson protectPerson = new ProtectPerson();
        protectPerson.setDaemon(true);//守护线程
        protectPerson.start();

        for(int i=0;i<20;i++)
        {
            System.out.println("小明准备去打工"+i);
        }
    }
}
class ProtectPerson extends Thread{
    @Override
    public void run() {
        while (true)
        {
            System.out.println("小红和隔壁老王谈人生");}
    }
}

线程的生命周期

要想实现多线程，必须在主线程中创建新的线程对象。Java语言使用Thread类及其子类的对象来表示线程，在它的一个完整的生命周期中通常要经历如下的五种状态：

新建： 当一个Thread类或其子类的对象被声明并创建时，新生的线程对象处于新建状态

就绪：处于新建状态的线程被start()后，将进入线程队列等待CPU时间片，此时它已具备了运行的条件

运行：当就绪的线程被调度并获得处理器资源时,便进入运行状态， run()方法定义了线程的操作和功能

阻塞：在某种特殊情况下，被人为挂起或执行输入输出操作时，让出 CPU 并临时中止自己的执行，进入阻塞状态

死亡：线程完成了它的全部工作或线程被提前强制性地中止

在这里插入图片描述

线程的同步

为什么要用同步

多个线程执行的不确定性引起执行结果的不稳定

多个线程对账本的共享，会造成操作的不完整性，会破坏数据。

多线程出现了安全问题

问题的原因

​ 当多条语句在操作同一个线程共享数据时，一个线程对多条语句只执行了一部分，还没有执行完，另一个线程参与进来执行。导致共享数据的错误

​ 解决办法

​ 对多条操作共享数据的语句，只能让一个线程都执行完，在执行过程中，其他线程不可以参与执行

火车站卖票案例

public class Train {
    public static void main(String[] args) {
  		SalePerson salePerson1 = new SalePerson();
        Thread thread = new Thread(salePerson1,"1号窗口");
        thread.start();
        Thread thread2 = new Thread(salePerson1,"2号窗口");
        thread2.start();
        Thread thread3 = new Thread(salePerson1,"3号窗口");
        thread3.start();

    }
}

/**
 * 买票案例
 */
class SalePerson implements Runnable {
    static int count = 100;
    public void run() {
        while (true) {
            //同步代码块 锁的对象
            synchronized (this) {
                if (count <= 0) {
                    System.out.println("票已卖完");
                    break;
                    }
                try {
                    Thread.sleep(10);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                count--;
                System.out.println(Thread.currentThread().getName() + "当前还剩" + count + "张票");
            }
        }
    }
}

Synchronized的使用方法

Java对于多线程的安全问题提供了专业的解决方式：

同步代码块

​ 1.synchronized (对象){

​ // 需要被同步的代码；

}

2.synchronized还可以放在方法声明中，表示整个方法为同步方法。

例如：

public synchronized void show (String name){

​ ….

}

同步锁(Lock)

从Java 5开始，Java提供了更强大的线程同步机制——通过显式定义同步锁对象来实现同步。同步锁使用Lock对象充当。

Lock是控制多个线程对共享资源进行访问的工具。锁提供了对共享资源的独占访问，每次只能有一个线程对Lock对象加锁，线程开始访问共享资源之前应先获得Lock对象。

在实现线程安全的控制中，比较常用的是ReentrantLock(可重入锁)，可以显式加锁、释放锁。

互斥锁

在Java语言中，引入了对象互斥锁的概念，来保证共享数据操作的完整性。

每个对象都对应于一个可称为“互斥锁”的标记，这个标记用来保证在任一时刻，只能有一个线程访问该对象。

关键字synchronized 来与对象的互斥锁联系。当某个对象用synchronized修饰时，表明该对象在任一时刻只能由一个线程访问。

同步的局限性：导致程序的执行效率要降低

同步方法（非静态的）的锁为this。

同步方法（静态的）的锁为当前类本身。

释放锁的操作

当前线程的同步方法、同步代码块执行结束

当前线程在同步代码块、同步方法中遇到break、return终止了该代码块、该方法的继续执行。

当前线程在同步代码块、同步方法中出现了未处理的Error或Exception，导致异常结束

当前线程在同步代码块、同步方法中执行了线程对象的**wait()**方法，当前线程暂停，并释放锁。

不会释放锁的操作

线程执行同步代码块或同步方法时，程序调用Thread.sleep()、Thread.yield()方法暂停当前线程的执行

线程执行同步代码块时，其他线程调用了该线程的suspend()方法将该线程挂起，该线程不会释放锁（同步监视器）。

应尽量避免使用suspend()和resume()来控制线程

线程的死锁问题

死锁

不同的线程分别占用对方需要的同步资源不放弃，都在等待对方放弃自己需要的同步资源，就形成了线程的死锁

解决方法

专门的算法、原则

尽量减少同步资源的定义

实现两个储户交替存钱的案例

1，明确哪些代码是多线程运行代码，须写入run()方法

2，明确什么是共享数据。

3，明确多线程运行代码中哪些语句是操作共享数据的。

public class YingHang {
    public static void main(String[] args) {
        Money money = new Money();
        Thread thread1 = new Thread(money,"第一个人");
        thread1.start();

        Thread thread2 = new Thread(money,"第二个人");
        thread2.start();
    }
}
class Money implements Runnable{
    static double counts=10000.0;
    @Override
    public void run() {
        while (true) {
            synchronized (this) {
                if (counts < 60000.0) {
                    counts += 1000;
                    System.out.println(Thread.currentThread().getName() + "存了1000," + "当前账户还有" + counts + "元");
                    //先唤醒另一个线程,后睡觉
                    this.notify();
                    try {
                        this.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                else
                    break;
            }
        }
    }
}

线程通信

wait() 与 notify() 和 notifyAll()

wait()：令当前线程挂起并放弃CPU、同步资源，使别的线程可访问并修改共享资源，而当前线程排队等候再次对资源的访问

notify()：唤醒正在排队等待同步资源的线程中优先级最高者结束等待

notifyAll ()：唤醒正在排队等待资源的所有线程结束等待.

Java.lang.Object提供的这三个方法只有在synchronized方法或synchronized代码块中才能使用，否则会报java.lang.IllegalMonitorStateException异常

wait() 方法

在当前线程中调用方法： 对象名.wait()

使当前线程进入等待（某对象）状态 ，直到另一线程对该对象发出 notify (或notifyAll) 为止。

调用方法的必要条件：当前线程必须具有对该对象的监控权（加锁）

调用此方法后，当前线程将释放对象监控权 ，然后进入等待

在当前线程被notify后，要重新获得监控权，然后从断点处继续代码的执行。

notify()/notifyAll()

在当前线程中调用方法： 对象名.notify()

功能：唤醒等待该对象监控权的一个线程。

调用方法的必要条件：当前线程必须具有对该对象的监控权（加锁）

银行取钱案例

1.定义一个Account类

1）该Account类封装了账户编号（String）和余额（double）两个属性

2）设置相应属性的getter和setter方法

3）提供无参和有两个参数的构造器

4）系统根据账号判断与用户是否匹配，需提供hashCode()和equals()方法的重写

2.提供一个取钱的线程类

1）提供了Account类的account属性和double类的取款额的属性

2）提供带线程名的构造方法

3）run()方法中提供取钱的操作

3.在主类中创建线程进行测试。考虑线程安全问题。

public class Test {
    public static void main(String[] args) {
        Account account = new Account("12345", 10000.0);
        GetMoney getMoney = new GetMoney(account,1000.0);
        Thread thread = new Thread(getMoney,"小明");
        thread.start();
        GetMoney getMoney2 = new GetMoney(account,1200.0);
        Thread thread2 = new Thread(getMoney2,"小李");
        thread2.start();

    }
}
//模拟银行取钱的问题
//1.定义一个Account类
//1）该Account类封装了账户编号（String）和余额（double）两个属性
//2）设置相应属性的getter和setter方法
//3）提供无参和有两个参数的构造器
//4）系统根据账号判断与用户是否匹配，需提供hashCode()和equals()方法的重写
class Account{
    private String id;
    private double money;

    public Account() {
    }

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

    public String getId() {
        return id;
    }

    public void setId(String id) {
        this.id = id;
    }

    public double getMoney() {
        return money;
    }

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

    @Override
    public String toString() {
        return "Account{" +
                "id='" + id + '\'' +
                ", money=" + money +
                '}';
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (!(o instanceof Account)) return false;
        Account account = (Account) o;
        if(this.getId().equals(((Account) o).getId()))
            return true;
        else return false;
    }

    @Override
    public int hashCode() {
        return id.hashCode();
    }
}

//2.提供一个取钱的线程类
//1）提供了Account类的account属性和double类的取款额的属性
//2）提供带线程名的构造方法
//3）run()方法中提供取钱的操作
//3.在主类中创建线程进行测试。考虑线程安全问题。

class GetMoney extends Thread{
   private Account account;
   private double putMoney;

    public GetMoney() {
    }

    public GetMoney(Account account, double putMoney) {
        this.account = account;
        this.putMoney = putMoney;
    }

    public Account getAccount() {
        return account;
    }

    public void setAccount(Account account) {
        this.account = account;
    }

    public double getPutMoney() {
        return putMoney;
    }

    public void setPutMoney(double putMoney) {
        this.putMoney = putMoney;
    }

    @Override
    public void run() {
        synchronized (this) {
            if (this.getPutMoney() <= account.getMoney()) {
                System.out.println(Thread.currentThread().getName() + "取款成功,还剩" + (account.getMoney() - this.getPutMoney()) + "元");
                //account.getMoney()-=this.getPutMoney();
            }
            else
                System.out.println("余额不足,取款失败");
            this.notify();
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

线程池

系统启动一个新线程的成本是比较高的，因为它涉及与os交互。这种情况下，系统启动时即创建大量空闲的线程，就可以很好地提高性能，尤其是当程序需要创建大量生存期很短暂的线程时。

除此之外，使用线程池可以有效地控制系统中并发线程的数量。避免因并发创建的线程过多，导致系统性能下降，JVM崩溃。

Java 5以前，需要手动创建自己的线程池；Java 5开始，新增了Executors工厂类产生线程池。

使用线程池执行线程任务的步骤如下：

1.调用Executors 类的静态方法newFixedThreadPool(int nThreads)，创建一个可重用的、具有固定线程数的线程池ExecutorService对象

2.创建Runnable实例，作为线程执行任务

3.调用ExecutorService对象的submit()提交Runnable实例

4.调用ExecutorService对象的shutDown()方法关闭线程池。

public class PoolTest {
    public static void main(String[] args) {
        //单例模式    池子:Executors
        ExecutorService pool1=Executors.newSingleThreadExecutor();
        //submit   提交
        pool1.submit(new MMM());
        //运行
        pool1.execute(new MMM());
        //关闭资源
        pool1.shutdown();

        //动态扩容
        ExecutorService pool3 = Executors.newCachedThreadPool();
        pool3.submit(new MMM());
        //运行
        pool3.execute(new MMM());
        //关闭资源
        pool3.shutdown();

        //静态扩容（尽量不用）直接把线程数量指定号
        ExecutorService pool2 = Executors.newFixedThreadPool(5);
        pool2.submit(new MMM());
        //运行
        pool2.execute(new MMM());
        //关闭资源
        pool2.shutdown();
    }
}
class MMM implements Runnable{
    @Override
    public void run() {
    }
}

leThreadExecutor();
//submit 提交
pool1.submit(new MMM());
//运行
pool1.execute(new MMM());
//关闭资源
pool1.shutdown();

    //动态扩容
    ExecutorService pool3 = Executors.newCachedThreadPool();
    pool3.submit(new MMM());
    //运行
    pool3.execute(new MMM());
    //关闭资源
    pool3.shutdown();

    //静态扩容（尽量不用）直接把线程数量指定号
    ExecutorService pool2 = Executors.newFixedThreadPool(5);
    pool2.submit(new MMM());
    //运行
    pool2.execute(new MMM());
    //关闭资源
    pool2.shutdown();
}

}

Zll0
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Java线程（二）
回忆的夏天
01-19 490
线程有它自己的生命周期，也就是五种状态：被创建，运行（start（）），临时状态、阻塞（具备运行资格，但没有执行权），冻结（放弃了执行资格），消亡（stop（）、run（）方法执行完成）。这里主要就是了解和掌握几个函数的应用和区别，例如我之前的一篇博客http://blog.csdn.net/lxjstudyit/article/details/52443872，sleep()和yield()方法区
声明银行账户类 java_编写Java程序，使用ThreadLocal类，项目中创建账户类 Account，类中包括账户名称name、 ThreadLocal 类的引用变量amount，表示存款...
weixin_30910893的博客
02-21 876
查看本章节查看作业目录需求说明：某用户共有两张银行卡，账户名称相同，但卡号和余额不同。模拟用户使用这两张银行卡进行消费的过程，并打印出消费明细 实现思路：项目中创建账户类 Account，类中包括账户名称name、 ThreadLocal 类的引用变量amount，表示存款创建消费类 DailyConsmption实现Runnable 接 口。声明 账户类型的引用 account， 使 用new ...
多线程（2）
孤独的大佬
11-04 301
线程的调度 调度策略 时间片 抢占式：高优先级的线程抢占CPU Java的调度方法 同优先级线程组成先进先出队列（先到先服务），使用时间片策略 对高优先级，使用优先调度的抢占式策略 线程的优先级 线程的优先级等级 MAX_PRIORITY：10 MIN _PRIORITY：1 NORM_PRIORITY：5 涉及的方法 getPriority() ：返回线程优先值 setPriority(int newPriority) ：改变线程的优先级 说明 线程创建时继承父线程的优先级 低优先级只是获得调度的概
编写程序Account.java，定义一个类Account，表示“银行账户”，
热门推荐
qq_44704200的博客
07-16 1万+
编写程序Account.java，定义一个类Account，表示“银行账户”，完成以下要求： （1）定义以下实例成员变量： 账号：String account 储户姓名：String name 存款余额：double balance （2）定义以下静态成员变量： 账户最小余额限制值：double minBalance （3）在静态代码块中初始化静态成员变量，账户最小余额为10元。 （4）定义构造方法以初始化实例成员变量accout、name和balance （5）定义存钱方法deposit，该方法调用后会.
java线程安全&通信练习
OceanStar的博客
07-14 482
银行有一个账户。有两个储户分别向同一个账户存3000元，每次存1000，存3次。每次存完打印账户余额 线程安全 package com.oceanstar; class Account{ private double balance; public Account(double balance) { this.balance = balance; } public synchronized void deposit(double amt){ .
java 多线程
11-07
### Java多线程知识点详解 #### 一、Java Thread 概念 在Java中，**线程**是一种轻量级的进程，它是程序执行流的最小单元。一个标准的Java应用通常至少包含一个线程，即主（Main）线程。Java支持多线程编程，这...
Java多线程详解及示例
最新发布
07-20
Java多线程编程是提升程序性能和响应性的关键技术。理解多线程的概念，掌握线程的创建、同步、通信、死锁避免等核心知识点，以及合理使用线程池，对于编写高效、稳定的并发程序至关重要。通过实践，开发者可以更好地...
Java多线程编程总结
01-31
要认识多线程就要从操作系统的原理说起。以前古老的DOS操作系统（V6.22）是单任务的，还没有线程的概念，系统在每次只能做一件事情。比如你在copy东西的时候不能rename文件名。为了提高系统的利用效率，采用批处理来...
java多线程
05-02
Java多线程是Java编程中的核心概念，它允许程序同时执行多个任务，提高了程序的效率和响应速度。在Java中，实现多线程有两种主要方式：通过实现`Runnable`接口和继承`Thread`类。 1. 实现Runnable接口 当一个类...
Java多线程读取大文件
12-22
【Java多线程读取大文件】是一种优化的文件处理策略，特别适用于处理大型文本文件。在传统的单线程I/O操作中，读取大文件可能导致内存溢出（OOM），尤其是在尝试一次性加载整个文件到内存时。为了避免这个问题，我们...
Java多线程下载器
09-26
Java多线程下载器是一种利用Java编程语言实现的高效文件下载工具，它通过将大文件分割成多个部分并同时下载，显著提高了下载速度。在Java中实现多线程下载器涉及许多关键概念和技术，包括线程、并发控制、网络I/O...
java多线程，对多线程，线程池进行封装，方便使用
05-16
Java多线程是Java编程中的重要概念，它允许程序同时执行多个任务，提高了程序的效率和响应速度。在Java中，我们可以通过实现Runnable接口或继承Thread类来创建线程。然而，直接使用线程可能存在一些问题，如资源管理...
Java多线程结构_Java多线程结构_
09-30
Java多线程结构是Java编程中的重要组成部分，它允许程序同时执行多个任务，提升系统效率。在Java中，实现多线程主要有两种方式：继承Thread类和实现Runnable接口。 1. 继承Thread类： 当自定义类继承Thread类时，...
Java多线程并发执行demo代码实例
08-18
"Java多线程并发执行demo代码实例" 在Java编程中，多线程并发执行是非常重要的概念，它可以提高程序的执行效率和响应速度。今天，我们通过一个demo代码实例来学习Java多线程并发执行的实现。 知识点1：泛型 在...
java多线程进阶
10-18
Java多线程是Java编程中的核心概念，尤其对于高级开发者来说，掌握多线程的深入理解和应用至关重要。这本书“java多线程进阶”显然旨在帮助读者深化这方面的理解，打通编程中的“任督二脉”，使开发者能够更加熟练地...
–定义Account类表示银行帐户 – 定义两个线程分别实现张三和妻子取款的操作
m0_64027170的博客
04-20 394
1. public class Account implements Runnable { private float money; public Account() { } public Account(float money) { this.money = money; } public float getMoney() { return money; } public void setMoney
第15章 多线程
MObaiYUhai的博客
10-14 502
15.5.4 练习2 模拟银行取钱的问题 1.定义一个Account类 1）该Account类封装了账户编号（String）和余额（double）两个属性 2）设置相应属性的getter和setter方法 3）提供无参和有两个参数的构造器 4）系统根据账号判断与用户是否匹配，需提供hashCode()和equals()方法的重写 2.提供一个取钱的线程类 1）提供了Account类...
Java 多线程小结
一枝韩独秀的博客
02-26 1179
1 程序、进程、线程的概念 程序(program)是为完成特定任务、用某种语言编写的一组指令的集合。即指一段静态的代码，静态对象。 进程(process)是程序的一次执行过程，或是正在运行的一个程序。动态过程：有它自身的产生、存在和消亡的过程。 如：运行中的QQ，运行中的MP3播放器 程序是静态的，进程是动态的 线程(thread)，进程可进一步细化为线程，是一个程序内部的一条执行路径。 若...
java基础-多线程
flytalei的博客
03-03 255
文章目录多线程概念 多线程概念 现实生活中有很多多线程的例子，比如人可以一边吃饭一边看电视，这吃饭看电视的同时还伴随着呼吸和大脑对电视剧情的思考。这种多个动作步骤同一时间一起执行的机制就称之为**“多线程”。Java将这种思想称之为并发**，并将并发完成的每一件事情称为线程。 ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值