线程（1）

最新推荐文章于 2024-05-16 13:19:04 发布
最新推荐文章于 2024-05-16 13:19:04 发布
阅读量404 收藏 2
点赞数 2
文章标签： p2p linq xml
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_60475929/article/details/122499838
版权

线程

线程（thread）是一个程序内部的一条执行路径

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

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

多线程

概述

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

多线程的作用

多线程的创建

方式一：继承Thread类

Thread类：

Java是通过java.lang.Thread类来代表线程

按照面向对象的思想，Thread类应该提供多线程的方式

方案：

  缺点；

        线程类已经继承了Thread类，无法继承其他类，不利于扩展

优点：

        编码简单

package com.itxue.d1_creat;
//多线程创建方式一：继承thread类实现
public class ThreadDemo01 {
    public static void main(String[] args) {
        Thread r = new MyThread();
        r.start();
        //执行的还是run方法
        for (int i = 0; i < 5; i++) {
            System.out.println("主线程执行输出"+i);
        }
    }
}

class MyThread extends Thread{
//    重写Run方法
    public void run(){
        for (int i = 0; i < 5; i++) {
            System.out.println("子线程执行输出"+i);
        }
    }
}

方式二：实现Runnable接口

方案

 Thread的构造器

package com.itxue.d1_creat;

public class ThreadDemo02 {
    public static void main(String[] args) {
//        创建一个任务对象
        Runnable r = new MyRunnable();
        Thread t = new Thread(r);
        t.start();
        for (int i = 0; i < 5; i++) {
            System.out.println("主线程执行输出"+i);
        }

    }
}
class MyRunnable implements Runnable{
    public void run(){
        for (int i = 0; i < 5; i++) {
            System.out.println("子线程在执行"+i);
        }

    }


}

优缺点

方案二：实现Runnable接口（匿名内部类形式）

package com.itxue.d1_creat;

public class ThreadDemo02Other {
    public static void main(String[] args) {
//        创建一个任务对象
       Runnable r =new Runnable() {
           @Override
           public void run() {
               for (int i = 0; i < 5; i++) {
                   System.out.println("子线程执行输出"+i);
               }
           }
       };
        Thread t = new Thread(r);
        t.start();
        for (int i = 0; i < 5; i++) {
            System.out.println("主线程执行输出"+i);
        }

    }
}


package com.itxue.d1_creat;

public class ThreadDemo02Other {
    public static void main(String[] args) {
//        创建一个任务对象
       Runnable r = new Runnable() {
           @Override
           public void run() {
               for (int i = 0; i < 5; i++) {
                   System.out.println("子线程1执行输出"+i);
               }
           }
       };
        Thread t = new Thread(r);
        t.start();

        new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < 10; i++) {
                    System.out.println("子程序3执行输出"+i);
                }
            }
        }).start();




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

    }).start();
        for (int i = 0; i < 5; i++) {
            System.out.println("主线程执行输出"+i);
        }
    }
}

方式三：JDK5.0新增：实现Callable接口

 方案

package com.itxue.d1_creat;

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

public class ThreadDemo03 {
    public static void main(String[] args) {
//创建任务对象
        Callable<String> call = new MyCallable(100);
//4.将Callable任务对象交给FutureTask对象
//        FutureTask对象的作用1：是Runnable的对象（实现了Runnable接口，可以交给Thread）
//        FutureTask对象的作用2：线程执行完毕之后通过get方法返回线程完成的结果
        FutureTask<String> f1 = new FutureTask<>(call);
//        5.交给线程处理
        Thread r = new Thread(f1);
        //6.启动线程
        r.start();


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

        try {
            String rs1 = f1.get();
            System.out.println("第二个线程的结果是："+rs1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
        try {
            String rs2 = f2.get();
            System.out.println("第二个线程的结果是"+rs2);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }

    }
}
class MyCallable implements Callable<String>{
    private int n;
    public MyCallable(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;
    }
}

 

Thread的常用方法

currentThread 那个主线程执行它，他就得到那个线程对象

 Thread的构造器

 

 Thread类的线程休眠方法

package com.itxue.d2_api;

public class ThreadDemo02 {
    public static void main(String[] args) throws Exception {
        for (int i = 0; i < 5; i++) {
            System.out.println("输出"+i);
            if (i == 3){
                Thread.sleep(3000);
            }
        }
    }
}

总结

 线程安全问题

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

实例演示

 总结

存在多线程并发

同时访问共享资源

存在修改共享资源

 案例：取钱案例

 Account类 

package com.itxue.d3_thread_safe;

public class Account {
    private String IdName;
    private int money;

    public Account() {
    }

    public Account(String idName, int money) {
        IdName = idName;
        this.money = money;
    }

    public String getIdName() {
        return IdName;
    }

    public void setIdName(String idName) {
        IdName = idName;
    }

    public int getMoney() {
        return money;
    }

    public void setMoney(int 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("余额不足");
        }
    }

}

Thread类 

package com.itxue.d3_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(100000);
    }
}

package com.itxue.d3_thread_safe;

public class ThreadDemo {
    public static void main(String[] args) {
        Account acc = new Account("ACBC-123",100000);

        new DrawThread(acc,"小明").start();
        new DrawThread(acc,"小红").start();


    }
}

线程同步

可以解决安全问题

线程同步的核心思想

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

 方式一：同步代码块

作用；把出现线程安全问题的核心代码上锁

 原理：每次只能一个线程进入，执行完毕后自动解锁，其他线程才可以进来执行        

锁对象的要求

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

锁对象的规范要求

1.锁对象用任意唯一的对象好不好？

        不好，会影响其他线程的执行（例如：小黑，小白也前来取钱需要等待小红，小明的之一的线程结束才可以执行） 

2.要求；

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

        对于实例方法建议使用this作为锁对象        

 

 Account类

        对于静态方法建议使用字节码（类名.class）对象作为锁对象     

   

同步方法

作用 ：把出现的线程安全问题的核心方法上锁

原理；每次只能一个线程进入，执行完毕后自动解锁，其他线程才可以进来执行执行

 同步方法的底层原理

 Lock锁

概述

Lock的API

package d5_thread_synchronized_lock.d3_thread_safe;

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

public class Account {
    private String IdName;
    private int money;
//    锁对象唯一且不可替换
    private final Lock lock = new ReentrantLock();
    public Account() {
    }

    public Account(String idName, int money) {
        IdName = idName;
        this.money = money;
    }

    public String getIdName() {
        return IdName;
    }

    public void setIdName(String idName) {
        IdName = idName;
    }

    public int getMoney() {
        return money;
    }

    public void setMoney(int money) {
        this.money = money;
    }
    public void drawMoney(double money){
        String name = Thread.currentThread().getName();

            lock.lock();
        try {
            if (this.money >= money) {
                System.out.println(name + "取钱成功，吐出" + money);
    
                this.money -= money;
                System.out.println(name + "取钱后，剩余的钱为" + this.money);
            } else {
                System.out.println(name + "余额不足");
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
      
    }

}

线程通信

线程通信案例模拟

线程通信的前提 ：线程通信通常是在多个线程操作同一个共享资源的时候需要进行通信，且要保证线程安全

Object类等待和唤醒的方法

package com.itxue.d6_thread_communication;

public class Phone {
    private boolean flag = false;
    public void run(){
        //负责来电提醒的线程
        new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    while (true){
                        synchronized (Phone.this){
                          if(!flag){
                              System.out.println("来电提醒");
                              flag = true;
                              Phone.this.notify();
                              Phone.this.wait();
                          }
                        }
                    }
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }

            }
        }).start();



        //负责接电话线程，正是接听
        new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    while (true){
                        synchronized (Phone.this) {
                            if (flag) {
                                //可以接听电话了
                                System.out.println("接听电话，通话五分钟");
                                Thread.sleep(5000);
                                flag = false;//代表继续等待接通电话
                                //等待自己，唤醒别人
                                Phone.this.notify();
                                Phone.this.wait();
                            }else{
                                Phone.this.notify();
                                Phone.this.wait();
                            }
                        }
                    }
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }).start();
    }

    public static void main(String[] args) {
        Phone xiaomi = new Phone();
        xiaomi.run();//开机了
    }

}

LIUEUX
关注
  • 2
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
11_线程（1）
love_knock_code的博客
12-14 242
同一个程序中的所有线程均会独立执行相同程序，且共享一份全局内存区域，其中包括初始化数据段、未初始化数据段，以及堆内存段。（传统意义上的UNIX进程只是多线程程序的一个特例，该进程只包含一个线程）调用fork来创建进程的代价相对较高，即便利用写时复制技术，仍然需要复制诸如内存页表和文件描述符之类的多种进程属性，这意味着fork调用在时间上的开销依然不菲。线程是轻量级的进程（LWP：Light Weight Process），在Linux环境下线程的本质是进程。6、连接已经终止的线程，用来回收子线程资源。
线程练习(1)
qq_45624490的博客
02-12 340
客户端服务器端交互 在单客户端与服务器聊天中引入线程,将发送消息和接收消息功能分别加入到线程中实现. //服务器端 public class Server { public static void main(String[] args) throws IOException { ServerSocket serverSocket=new ServerSocket(9999); Socket socket=serverSocket.accept();//监听
new Thread(new Runnable(){})
麦七的博客
08-10 3万+
JAVA是面向对象的，也就是说，对于一个方法等，它需要什么类型的对象，只要传入就可以了。 像这里，Thread类的构造方法中，需要一个实现了Runnable接口的对象，而new就是生成了个Runnable接口下的一个实例对象。 同等与这种写法，实例化了一个Runnable接口子类的实例 Thread t=new Thread(new MyRunnable()); public class MyRunnable implements Runnable{ @Override public void run(
Java多线程
hashmapdemo的博客
04-20 1426
目录 1、多线程技术概述 2、多线程的实现 3、Thread类详解 4、线程的休眠、阻塞及中断 5、守护线程 6、线程安全问题（使用锁） 7、多线程通信（生产者与消费者） 8、线程的六种状态 9、线程池 一、多线程技术概述 1、线程与进程 进程： 是指一个内存中运行的应用程序，每个进程都有一个独立的内存空间 线程： 是进程中的一个执行路径，共享一个内存空间，线程之间可以自由切换，并发执行，一个进程最少有一个线程 线程实际上是在进程基础之上的进一步划分，一个进程启动之后，里面的
Java多线程（二）：线程的常用方法和状态_&quot；java的new thread (thread, &quot；窗口1 &quot；)(1)
最新发布
2401_84975387的博客
05-16 350
既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，涵盖了95%以上C C++开发知识点，真正体系化！由于文件比较多，这里只是将部分目录截图出来，全套包含大厂面经、学习笔记、源码讲义、实战项目、大纲路线、讲解视频，并且后续会持续更新如果你需要这些资料，可以戳这里获取 TimeUnit.DAYS.sleep(1);//天 TimeUnit.HOURS.sleep(1);//⼩时 TimeUnit.MINUTES.sleep(1);//分 TimeUnit.SEC
Java中Thread类的基本用法
m0_67683346的博客
08-19 5867
Java中的Thread类的基本使用
new Thread() 的危害
qq_34253002的博客
09-07 5812
1）开销大 每次new Thread() 都会创建新的对象，开销较大，无法复用增加垃圾回收的负担。 2）管理困难 每个newThread() 都是独立的个体，无法有效的管控，无限制创建相互竞争，可能导致oom或者核心业务线程阻塞。 3）功能单一 无法定时执行，中断线程等功能。
线程系列二：Thread构造函数
sys的博客
12-13 1662
线程系列二：Thread构造函数 文章目录线程系列二：Thread构造函数前言一、new Thread二、与jVM1.与内存的关系2.线程创建的数量三、守护线程 前言 在我们开始学线程的时候新建一个线程用的什么？new Thread()相信大家都很熟悉，不知道大家有没有深入理解过这个函数 一、new Thread 有一下几个知识点: new Thread(“t1”) 可以传入一个参数作为线程的名字，如果没有会默以"Thread-"作为前缀递增 在线程是new状态时可以修改线程名字其他状态将不能修
实验八 线程1
08-04
实验八线程1 实验八线程1是南方科技大学计算机操作系统实验课程的一部分，旨在加深对线程的理解，掌握多线程基本编程方法，多线程之间同步与互斥的方法。下面是实验八线程1的详细知识点： 1. 线程基本知识 线程是...
JavaPD-Ch08mao线程1
08-03
Java线程有10个优先级，从Thread.MIN_PRIORITY（1）到Thread.MAX_PRIORITY（10），默认优先级为Thread.NORM_PRIORITY（5）。优先级较高的线程通常会先得到执行机会，但线程调度主要由操作系统决定，Java线程优先级并...
08_第8章 线程1
08-03
1. `start()`：启动线程，调用run()方法。 2. `run()`：线程执行的主要逻辑。 3. `sleep(long millis)`：让当前线程暂停指定毫秒数，释放CPU执行权。 4. `currentThread()`：返回当前正在执行的线程对象。 线程同步...
02-2-进程与线程之线程1
08-03
线程是操作系统中的一种基本执行单元，它在程序执行中扮演着重要角色。在操作系统领域，线程的引入主要是为了实现并发性和资源分享。本文将深入探讨线程的概念，包括线程的定义、多线程进程的优势以及线程与进程的...
哈工大操作系统-L11内核级线程1
08-03
1. **核心级线程与用户级线程的不同** - **创建与销毁**：用户级线程由用户空间的线程库管理，创建和销毁不需要经过内核；而内核级线程由操作系统内核直接控制，创建和销毁涉及到内核态的上下文切换。 - **调度...
浅谈new Runnable()
热门推荐
平凡之路
08-22 3万+
转自：https://blog.csdn.net/c_p_h/article/details/70473673?locationNum=1&amp;fps=1 参考： https://www.cnblogs.com/lanzhi/p/6467266.html //匿名内部类中关于new Runnable()的使用 http://wiki.jikexueyuan.com/project/jav...
Java学习（9）—— 多线程
Archer__13的博客
11-01 834
多线程的创建
【多线程】Thread 类及常见方法
m0_60494863的博客
05-14 4993
1.Thread 类 在Java标准库中，提供有一个Thread,来表示/操作线程。 Thread 类也可以视为Java 标准库提供的API。 创建好的 Thread 实例，其实和操作系统中的线程是一一对应的关系。 操作系统，提供了一组关于线程API（C语言风格），Java对于这组API进一步封装了，就成了Thread类 2.创建线程 2.1继承Thread 类 通过Thread 类创建线程，最基本的做法就是创建子类，继承自Thread ，并且重写run方法 （1）继承Thread 来创建一
java多线程——Thread类基本用法
weixin_60778429的博客
07-23 2317
本文主要用于总结多线程中Thread类的基本用法，不会涉及太多知识点，若想翻看更多有关多线程的知识点可看往期有关多线程的文章java多线程基础（中）_invictusQAQ的博客-CSDN博客。
【Java多线程】【Thread类及常见方法】
OTO233的博客
07-19 750
Thread类是 JVM用来管理线程的一个类，每个线程都有一个唯一的相关联的Thread对象；每个执行流需要一个对象描述，就是Thread类的对象，JVM讲这些Thread对象组织起来，用于线程调度，线程管理；
创建线程的四种方式（Thread、Runnable、线程池、Callable）
qq_46111269的博客
08-04 3803
创建线程有四种方式：1、继承Thread类 2、实现Runnable接口 3、通过线程池创建 4、实现Callable接口，下面是具体介绍
在线程1中开线程2 线程1释放线程二也随之释放怎么做
11-02
可以使用Python中的Thread.join()方法来实现线程的等待和释放。具体实现方法如下： 1. 在线程1中创建线程2，并启动线程2。 2. 在线程1中调用线程2的join()方法，使线程1等待线程2执行完毕。 3. 在线程1中执行完毕后，线程2也会随之释放。 以下是示例代码： ``` import threading def thread2(): print("Thread 2 started") # 线程2的任务 print("Thread 2 finished") def thread1(): print("Thread 1 started") # 创建线程2并启动 t2 = threading.Thread(target=thread2) t2.start() # 等待线程2执行完毕 t2.join() print("Thread 1 finished") # 启动线程1 t1 = threading.Thread(target=thread1) t1.start() ```

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值