Java学习笔记day10——多线程相关

最新推荐文章于 2024-05-21 19:15:40 发布
最新推荐文章于 2024-05-21 19:15:40 发布
阅读量142 收藏
点赞数
分类专栏： java自学刷题 文章标签： java 学习 jvm
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_40393126/article/details/129216734
版权

【相关名词解释】

1. 程序

一组指令的集合，是静态的。

2. 进程

一个程序的一次运行

当程序启动后，操作系统就会给这个程序分配一个进程的ID，并且会给他分配一块独立的内存空间。

若一个程序被启动了多次，就有多个进程

多个进程之间无法共享数据

如果两段代码需要进行数据交互，成本比较高（通过硬盘或网络）

进程之间的切换成本也比较高，现在操作系统都支持多任务，操作系统在每一个任务之间进行任务，要给进程做镜像，要记录当前进程的状态，执行到哪个指令了

操作系统分配资源的最小单位是进程

每一个进程至少有一个线程

3. 线程

进程中的其中一条执行路径，多个线程会属于同一个进程

这多个线程会共享同一个进程中的一些资源，比如Java中堆内存的数据，比如方法区的数据等

如果两段代码需要进行数据交互，可以直接在内存中操作（会出现安全问题）

线程之间的切换，需要记录的数据少很多，因为很多线程数据是共享的，这部分不需要单独镜像，只需要记录每一个线程要执行的下一条指令

CPU调度的最小单位是线程

4. JVM

（1）方法区

（2）堆

（3）Java虚拟机栈

（4）本地方法栈

（5）程序计数器：记录每一个线程要执行的下一条指令

Java程序一个main方法，就是一个进程，但是可以在main中，再开启多个线程

Java程序后台有几个线程是默默运行的：GC线程、异常的检查和处理、类加载

5. 并行和并发

并行：指两个或多个事件在同一时刻发生（同时发生），指在同一时刻，有多个指令在多个处理器上同时执行

并发：指两个或多个事件在同一事件段内发生，在同一时刻只能有一条指令执行，但多个进程的指令被快速轮换执行，使得在宏观上有多个进程同时执行的效果

6. 线程调度

（1）分时调度

所有线程轮流使用CPU的使用权，平均分配每个线程占用CPU的时间

（2）抢占式调度

优先让优先级高的线程使用CPU，如果线程的优先级相同，那么会随机选择一个（线程随机性），Java使用的为抢占式调用

【多线程】

创建方式有四种：

继承Thread、实现Runnable接口、实现Callable接口、线程池（这里学两种）

1. 多线程的创建和启动方式一：继承Thread类

步骤：

（1）编写一个类，让他继承Thread类

（2）重写父类的public void run(){}，该方法不是由程序员调用，而是线程调度时，自动调用

要让一个线程做什么事，必须把这个代码写到run中，run()的方法体，称为线程体

（3）创建自定义线程类的对象

（4）启动线程

调用自定义线程类对象的start()方法——启动线程方法

【注】不要手动调run()方法，run()方法是顺序执行，start()方法是多线程

如：

public class ThreadTest {
    public static void main(String[] args) {
        new Thread(){
            @Override
            public void run() {
                for(int i = 2;i <= 10;i+=2){
                    System.out.println("在线程内："+i);
                }
            }
        }.start();
        for (int i = 1;i<10;i+=2){
            System.out.println("在main中："+i);
        }
    }
}

2. 多线程的创建和启动方式二：实现Runnable接口

步骤：

（1）编写线程类，实现Runnable

（2）重写接口的抽象方法public void run()

（3）创建自定义对象类

（4）创建一个Thread对象类，让Thread对象类代理自定义线程类对象

（5）启动线程

如：

public class RunnableTest  {
    public static void main(String[] args) {
        MyRunnable my = new MyRunnable();
        Thread t = new Thread(my);
        t.start();
    }
}
class MyRunnable implements Runnable{
    @Override
    public void run() {
        for(int i = 2;i<=10;i+=2){
            System.out.println("线程内："+i);
        }
    }
}

 3. Thread类的方法

（1）构造方法

public Thread()：分配一个新的线程对象

public Thread(String name)：分配一个指定名字的新的线程对象

public Thread(Runnable target)：分配一个带有指定目标新的线程对象

public Thread(Runnable target,String name)：分配一个带有指定目标的星的线程对象并命名

String getName()：获取线程名字

        如果没有手动指定线程名称，默认是Thread-编号，从0开始

        如果需要手动指定线程名称，可以通过构造器，或者setName(String name)方法

static Thread currentThread()：获取执行当前语句的线程对象

（2）线程优先级

public final int getPriority()：返回线程优先级

public final void setPriority(int newPriority)：改变线程优先级

线程优先级高的，有更多的机会/概率被优先调用

t.setPriority();
java.lang.IllegalArgumentException
当设置的优先级不在MIN_PRIORITY到MAX_PRIORITY范围内，就会报这个异常
正常范围：1~10

（3）和线程的状态有关的方法

public static void sleep(long millis)throws InterruptedException：线程休眠，单位（毫秒）

public static void yield()：让当前线程暂停一下，让出CPU，但是下次CPU还是原来的调用

public join()：等待该线程终止。该线程是调用join方法的线程（加塞、阻塞）

        在（）内添加时间，就是阻塞该时间，时间到了之后继续抢CPU

如：

public class ThreadTest {
    public static void main(String[] args) throws InterruptedException {
       Thread t = new Thread("偶数线程"){
       public void run(){
           for(int i = 2;i<=100;i+=2){
               System.out.println(i+getName());
               try {
                   Thread.sleep(1000);
               } catch (InterruptedException e) {
                   e.printStackTrace();
               }
           }
       }
       };
       t.start();
       for(int i = 1;i<100;i+=2){
           System.out.println(i+Thread.currentThread().getName());
           if(i == 5){
               Thread.currentThread().join();
               //让奇数线程彻底暂停，让出全部CPU，直到偶数线程走完再继续
           }
       }
    }
}

线程练习1：加塞

自定义线程类ChatThread：问是否结束（输入Y/y结束），如果输入的不是y，继续问是否结束，知道输入y才结束。

主线程打印[1,10]，每隔10毫秒打印一个数字，现在当主线程打印完5之后，就让自定义线程类加塞，直到自定义线程类结束，主线程再继续

代码：

import java.util.Scanner;

class ChatThread extends Thread{
    Scanner input = new Scanner(System.in);

    @Override
    public void run() {
        while(true){
            System.out.println("请确认是否结束？Y/y");
            char answer = input.next().charAt(0);
            if(answer == 'Y'||answer == 'y'){
                break;
            }
        }
    }
}

public class TestThread {
    public static void main(String[] args) {
        for(int i = 1;i<=10;i++){
            System.out.println(i);
            if(i == 5){
                ChatThread t= new ChatThread();
                t.start();
                try {
                    t.join();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            try {
                Thread.sleep(10);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

先把该写的逻辑写全，然后补上try…catch

线程练习2：修改和加塞

编写龟兔赛跑多线程程序，设赛道长度为30米

兔子的速度为10米每秒，兔子每跑完10米休眠的时间10秒

乌龟的速度是1米每秒，乌龟每跑完10米的休眠时间是1秒

要求：要等兔子和乌龟的线程结束，主线程（裁判）才能公布最后的结果

提示：System.currentTimeMillis()方法扩返回当前时间的毫秒值（long 类型）

分析：跑道长度为30米，即从0循环到30

兔子速度为10米每秒，即兔子跑1米用时100毫秒

乌龟速度为1米每秒，即乌龟跑1米用时1000毫秒

代码：

兔子类：

public class Rabbit extends Thread{
    long time;
    public Rabbit(String name) {
        super(name);
    }

    @Override
    public void run() {

        long start = System.currentTimeMillis();
        for(int i = 1;i<=30;i++){

            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(getName()+"跑了"+i+"秒");
            if(i == 10||i == 20){
                try {
                    Thread.sleep(10000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
        long end = System.currentTimeMillis();
        time = end-start;
        System.out.println(getName()+"耗时："+(end-start));
    }
}

乌龟类

public class Gui extends Thread {
    long time;
    public Gui(String name) {
        super(name);
    }

    @Override
    public void run() {
        long start = System.currentTimeMillis();
        for (int i = 1; i <= 30; i++) {
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(getName() + "跑了" + i + "秒");
            if (i == 10 || i == 20) {
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
        long end = System.currentTimeMillis();
        time = end-start;
        System.out.println(getName()+"耗时："+(end-start));
    }
}

测试类：

public class Competition {
    public static void main(String[] args) {
        Gui g = new Gui("乌龟");
        Rabbit r = new Rabbit("兔子");

        g.start();
        r.start();
        try {
            r.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        try {
            g.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        if(g.time > r.time){
            System.out.println("兔子胜");
        }else {
            System.out.println("乌龟胜");
        }
    }
}

4. 线程的停止

原本有stop()，但是已过时。

替换为flag，放入for循环的条件判断中，如：

通过join()方法等待快的线程结束，结束后，改变慢线程的boolean值，从而实现慢线程停止

public class StopTest {
    public static void main(String[] args) {
        Odd o = new Odd();
        Even e = new Even();
        o.start();
        e.start();
        try {
            e.join();
        } catch (InterruptedException ex) {
            ex.printStackTrace();
        }
        o.setFlag(false);
    }
}
class Odd extends Thread{
    boolean flag = true;
    @Override
    public void run() {
        for(int i = 1;i<=100&&flag;i+=2){
            System.out.println(i);
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
    public void setFlag(boolean flag) {
        this.flag = flag;
    }
}
class Even extends Thread{
    @Override
    public void run() {
        for(int i = 2;i <= 100;i+=2){
            System.out.println(i);
        }
    }
}

线程练习3：龟兔赛跑优化（通过比较距离）

将重复代码进行优化，整合为一个类，通过创建线程对象进行调用

代码为：

Sporter类：

public class Sporters extends Thread{
    private int distance;
    private final  int MAX_DISTANCE = 30;
    private static boolean flag = true;
    private int restTime;
    private int runTime;

    public Sporters(String name, int restTime, int runTime) {
        super(name);
        this.restTime = restTime;
        this.runTime = runTime;
    }

    @Override
    public void run() {
        while(distance <MAX_DISTANCE && flag){
            try {
                Thread.sleep(runTime);
                distance++;
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(getName()+"跑了"+distance);

            if(distance == 10 || distance == 20){
                try {
                    Thread.sleep(restTime);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
        if(distance == MAX_DISTANCE){
            System.out.println(getName()+"已经到达终点");
            flag = false;
        }
    }

    public int getDistance() {
        return distance;
    }
}

测试类：

public class NewCompetition {
    public static void main(String[] args) {
        Sporters tu = new Sporters("兔子", 10000, 100);
        Sporters gui = new Sporters("乌龟", 1000, 1000);
        tu.start();
        gui.start();
        try {
            tu.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        try {
            gui.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        if (tu.getDistance() > gui.getDistance()) {
            System.out.println("兔子胜");
        } else {
            System.out.println("乌龟胜");
        }
    }
}

5. 线程安全

当使用多个线程访问同一资源（文件、变量、记录等）的时候，如多个线程只有读操作，就不会发生安全问题，但是如果多个线程中对资源有读写操作，就容易出现安全问题

（1）局部变量是不能共享的

因为每一个线程对象，都会调用一次run方法，而方法的每一次调用在“栈”中都会开辟独立内存空间

（2）实例变量可以共享，但前提是同一个对象

即，不使用继承，而使用接口实现线程去代理或者使用静态变量

如：

public class Tickets {
    public static void main(String[] args) {
        Tick t = new Tick();
        Thread t1 = new Thread(t);
        Thread t2 = new Thread(t);
        Thread t3 = new Thread(t);
        t1.start();
        t2.start();
        t3.start();
    }
}
class Tick implements Runnable{
    private int i = 10;
    @Override
    public void run() {
        while(i>1){
            i--;
            System.out.println(Thread.currentThread().getName()+"卖出一张，剩余"+i+"张");
        }
    }
}

6. 如何解决安全问题？

（1）使用同步机制

同步就是给某段代码加“锁”

锁是一个对象，又被称为监视器对象。就是监视使用共享数据的这几个线程的调度执行情况

Java分为3个对象

①对象头：当前对象类所属的指针、MarkWord（GC、锁标记）、数组长度

②对象的实例变量

③对齐空白

即每一个对象都有一个标记位，标记当前哪个线程“占有”这个锁对象

这个标记位会记录这个线程的ID，只有“占有”锁对象的线程才有机会执行被锁的代码，称为同步代码

（2）如何给代码加锁：synchronized

①同步代码：锁整个方法

【修饰符】synchronized 返回类型 方法名(【形参列表】){     方法体   }

②同步代码块：锁方法里的一部分

synchronized(锁对象){

        需要被锁起来的代码

}

如：将上面的卖票过程进行优化：

public class Tickets {
    public static void main(String[] args) {
        Tick t = new Tick();
        Thread t1 = new Thread(t);
        Thread t2 = new Thread(t);
        Thread t3 = new Thread(t);
        t1.start();
        t2.start();
        t3.start();
    }
}
class Tick implements Runnable{
    private int i = 100;
    @Override
    public void run() {
        while(i>1){
            oneTicket();
        }
    }
    public synchronized void oneTicket(){
        if(i>=1){
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            i--;
            System.out.println(Thread.currentThread().getName()+"卖出一张，剩余"+i+"张");
        }
    }
}

（3）什么时候释放锁？

当synchronized锁住的代码全部执行完才会释放锁

（4）锁对象的选择问题

①任意类型的对象都可以当做监视线程的锁对象，无限制

②必须保证使用共享数据的多个线程，使用的是同一个锁对象

③同步方法的锁对象是不能自由选择的，是默认的

非静态方法的锁对象是this对象

静态方法的锁对象是当前类的Class对象

如，将上题再次进行优化：添加票对象

public class Ticket {
    private final int MAX_TOTAL = 10;
    private int total = MAX_TOTAL;

    public synchronized void sale(){
        if(total > 0){
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            total --;
            System.out.println(Thread.currentThread().getName()+"卖出一张票，还剩"+total);
        }else{
            System.out.println("没有票了");
        }
    }
    public boolean check(){
        return total>0;
    }
}

main中启动线程：

public class Test {
    public static void main(String[] args) {
        Ticket t = new Ticket();
        new Thread("窗口一"){
            @Override
            public void run() {
                while(t.check()){
                    t.sale();
                }
            }
        }.start();
        new Thread("窗口二"){
            @Override
            public void run() {
                while(t.check()){
                    t.sale();
                }
            }
        }.start();
    }
}

7. 什么是单例设计模式

（1）设计模式

程序员根据自己的经验总结出来的代码模板、套路

常见设计模式有23种

（2）单例设计模式

某个类的对象在整个应用程序中只有唯一的一个

如：Java中的JVM对象

（3）如何实现单例

①构造器私有化

②在类的内部创建好这个类的唯一对象

（4）单例设计模式的形式

①饿汉式

无论是否用到这个类的对象，在类初始化的时候，直接创建对象

②懒汉式

等需要对象时再创建

8. 线程通信的等待唤醒机制

wait()

notify()：一般使用notifyall()

当这两个方法不是线程的监视器对象调用时，会报IllegalMonitorStateException（非法监视器）异常

监视器对象：同步锁对象

EXMo
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
java分布式应用学习笔记05多线程下的并发同步器.pdf
11-29
java分布式应用学习笔记05多线程下的并发同步器.pdf
Day20Java学习笔记——多线程学习
u013583756的博客
11-28 221
help —> Keymap Reference 找到快捷键 Java多线程 1.进程和线程 1.1串行与并行 串行：多个任务按顺序执行； 并行：多个任务同时执行； 1.2并行与并发 并行：多个CPU实例或者多台机器同时执行一段逻辑处理，是真正的同时； 并发：通过CPU调度算法，让用户看上去同时执行，实际上CPU操作层面不是真正的同时； 1.3进程与线程 进程： 具有独立的执行...
Java学习笔记day6——Object类、静态、枚举
qq_40393126的博客
02-21 281
Java学习笔记day6——Object类、静态、枚举
JAVA学习笔记Day02——基本语法
小冯的Blog
07-27 401
循环、方法
java编程思想学习笔记——21多线程
Burnup_110的博客
04-01 314
一、并发简介 实现并发最直接的方式是在操作系统级别使用进程。进程是运行在它自己的地址空间内的自包含的程序。多任务操作系统可以通过周期性地将CPU 从一个进程切换到另一个进程，来实现同时运行多个进程（程序）。对于进程来说，他们之间没有任何彼此通信的需要，因为他们都是完全独立的。 但是如果将进程当做并发的唯一选择，那么进程来做并发来说的话，也有他的局限性，因为进程通常来说是有数量和开销的限制的，以避免他们在不同的并发系统之间的可应用性 java采用在顺序型语言的基础上提供对线程的支持，即线程机制是在由执行程序表
java IO流学习笔记——(1)文件字节流
12-21
java IO流学习笔记——(1) IO流总述 • 输入流：数据源到程序(InputStream、Reader读进来) • 输出流：程序到目的地(OutputStream、Writer写出去) 流分类 : • 节点流：可以直接从数据源或目的地读写数据 • 处理...
JAVA学习笔记第七天——示例代码Day07
07-19
JAVA学习笔记第七天——示例代码Day07，其中包含访问修饰符示例代码、final关键字示例代码、接口示例代码、接口和类的关系示例代码
JAVA学习笔记第八天——示例代码Day08
07-19
JAVA学习笔记第八天——示例代码Day08，包含接口作为方法参数和返回值示例代码、多态示例代码、内部类示例代码
Java基础 学习笔记 Markdownr版
06-27
Java基础 java学习笔记 Java Java基础Markdown学习笔记，可转换成PDF、Word等格式
android高斯模糊填充imageview背景
最新发布
cf8833的博客
05-21 215
说明：最近碰到一个需求，安卓app显示在线的url图片，然后imageview没占满的部分，使用该图片的模糊背景填充。
docker中安装jenkins，并在node和cloud上跑通基于源码控制SCM的pipeline
qq_29022265的博客
05-19 1185
从安装jenkins到创建jenkins的node和cloud，最后再将scm和FreeStyle两种流水线跑通。
分布式锁2-Zookeeper分布式锁实战
qq_43676797的博客
05-19 339
使用curator操作Zookeeper进行实战；：Apache Curator包含一套高级API框架和工具类，它 是Apache ZooKeeper 的Java 客户端库。
java数据结构与算法(验证二叉搜索树)
磐门的博客
05-17 427
节点返回空为ture,节点的值不在对应数据大小范围内返回false。将验证二叉搜索树计算同样可以转换为相同子问题，所以比较适合用递归。node为root的左节点时，max更新为root.val。node为root的右节点时，min更新为root.val。
Kubernetes 审计日志采集与分析最佳实践
观测云的博客
05-17 1144
​Kubernetes 在 1.7 版本中发布了审计（Audit）日志功能，通过审计日志，我们能够非常清晰的知道 K8S 集群到底发生了什么事情。
Android Model引入其他aar包 导致无法打包成aar
qq_27400335的博客
05-16 399
Android Model引入其他aar包 导致无法打包成aar
Java基础——字符串
Kenard的博客
05-17 1002
基本数据类型、包装类 转成字符串，调用String类的public String valueOf(int n)可将int型转换为字符串相应的valueOf(byte b)、valueOf(long l)、valueOf(float f)、valueOf(doubled)、valueOf(boolean b)可由参数的相应类型到字符串的转换。下面示例中，s1 和 s2 采用 new String() 的方式新建了两个不同字符串，而 s3 和 s4 是通过 s1.intern() 方法取得一个字符串引用。
初识Spring Cloud
u011627218的专栏
05-20 761
一、介绍。
MyBatis从浅入深
Cobrander2_0的博客
05-21 621
Mybatis用于简化Java当中对于JDBC的操作，它将连接数据库，执行SQL命令自动化实现。
Java学习笔记之三——Java用户登陆界面
06-12
另外，关于Java用户登录界面，我可以为你提供一些简单的指导。首先，你需要使用Java Swing库来创建GUI界面，然后使用JDBC连接数据库，验证用户输入的用户名和密码是否正确。具体实现方法可以参考Java官方文档或者...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值