测试方向基础-多线程知识和常见示例

已于 2022-03-19 12:25:19 修改
阅读量356 收藏
点赞数
文章标签： java 自动化
于 2022-03-18 23:37:05 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_64360878/article/details/123587024
版权

文章目录

线程和多线程

个人理解：多线程产生的意义在于提高效率，什么样的程序需要使用多线程？比如一个程序是卖饭的一个过程，多个线程就相当于多个厨师，厨师多了，再需求不变的情况下效率就高了，但是客人给钱是要一个人一个人来的，这样可以避免因为很多人同时交钱而出现账目混乱。所以如果把这个过程比作一个程序，上半段代码写做饭，下半段代码写收钱，上半端代码是提高效率的根本所在，所有线程都可以同步执行，下半段代码需要加锁，所有线程竞争cpu使用权，一次只能执行一个。

程序、进程、线程的区别：

  • 程序是一段静态的代码，是应用软件执行的蓝本。
  • 进程是程序的一次动态执行过程，它对应了从代码加载、执行至执行完毕的一个完整过程，这个过程也就是进程本身从产生、发展至消亡的过程。
  • 线程是比进程更小的执行单位。进程在执行过程中可以产生多个线程，形成多条执行线索，每条线索，即每个线程也有它自身的产生、存在和消亡的过程，也是一个动态的概念。
    • 主线程：每个java程序都有一个默认的主线程，当JVM加载代码发现main方法之后，就会立即启动一个线程，这个线程称为主线程。主线程是产生其他子线程的线程，不一定是最后完成执行的线程。
    • 单线程：main方法中没有创建其他线程。
    • 多线程：main方法中又创建了其他线程。

线程的声明周期：

线程完整的生命周期包括五个状态：新建、就绪、运行、阻塞和死亡。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-QxExd8Y4-1647617363437)(C:\Users\yyc\AppData\Roaming\Typora\typora-user-images\image-20220314161847824.png)]

  • 新建：线程对象已经创建，还没在其上调用start()方法。
  • 就绪状态：当线程调用start方法，但调度程序还没有把它选定为运行线程时所处的状态。
  • 运行状态：线程调度程序从可运行池中选择一个线程作为当前线程时所处的状态。这也是线程进入运行状态的唯一方式。
  • 阻塞状态：线程仍旧时活得，但是没有条件运行。它时可运行的当某件事件出现，他可能返回到可运行状态。！！！！！注意！！阻塞状态被唤醒后从阻塞代码段开始向下执行。
  • 死亡状态：当线程的run()方法完成时就认为它死去。线程一旦死亡，就不能复生。一个死去的线程上调用start()方法，会抛出异常

用java语言创建多线程：

  • 创建线程有两种方式：

    • 通过继承Thread类实现多线程：

      public class MyThread extends Thread{
    public void run(){……}
    public static void main(String[] args){
        MyThread t1=new MyThread().start();
        MyThread t2=new MyThread().start();
    }
}
      • 优点：编写简单，访问当前线程直接使用this即可。
      • 缺点：不能再继承其他类

    • 实现Runnable接口实现多线程：

      public class MyThread implement Runnable{
    public void run(){……}
    public static void main(String[] args){
        MyThread m=new MyThread();
        Thread t1=new Thread(m);
        Thread t2=new Thread(m);
    }
}

      • 优点：可以继承其他类，非常适合多个相同线程来处理同一份资源的情况。

      • 缺点：访问当前线程必须使用Thread.currentThread()方法。

  • 常用的方法和常识

    • setName():自定义线程名字。

    • getName():返回此线程的名称。

    • Thread.currentThread():返回对象当前正在执行的线程对象的引用。

    • start():启动线程，让线程从新建状态进入就绪队列排队。此线程开始执行，Java虚拟机就会调用run()方法

    • run():线程对象被调度之后执行的操作。

    • Thread.sleep()：暂停线程的执行，让当前线程休眠若干毫秒。

    • isAlive():测试线程的状态，新建，死亡状态的线程返回false。

    • interrupt():”吵醒“休眠的线程，唤醒”自己“。

    • Thread.yield():暂停正在执行的线程，让同等优先级的线程运行，进入就绪状态。

    • join()：当前线程等待调用该方法的线程结束后，再排队等待CPU资源，进入阻塞状态。

    • stop()：终止线程。

    • setPriority()设置优先级。

    • wait()：

      1.wait()是Object里面的方法，而不是Threadl里面的，所以应该在对象上调用该方法而不是在线程上调用。
2.它的作用是将当前线程置于预执行队列，并在wait()所在的代码处停止，等待唤醒通知，唤醒后从暂停出继续执行。
3.wait()只能在同步代码块或者同步方法中执行，如果调用wait()方法，而没有适当的锁，就会抛出异常。
4.wait()方法调用后会释放出锁，线程与其他线程竞争重新获得锁。

    • notify()：该方法也是要在同步代码块或者同步方法中调用的，作用是使停止的线程继续执行。

    • 一个线程只能被启动一次。

    • JVM调度线程采用队列的形式

多线程的同步和死锁问题：

多线程程序再设计上最大的困难在于各个线程的控制流彼此独立，使得各个线程之间的代码时乱序执行的，而且各个线程共享资源，所以多线程会带来线程调度，同步，死锁等一系列问题。

  • 线程同步：当两个或两个以上线程访问同一资源时，需要某种方式来确保资源再某一时刻只被一个线程使用。

    • 用对象互斥锁来解决：关键字synchronized与对象互斥锁联合起来使用保证对象再任意时刻只能由一个线程访问，synchronized可修饰方法，表示这个方法在任意时刻只能由一个线程访问，synchronized可以修饰类，表示该类的所有对象共用一把锁。下面会有使用例子

    • 虽然我们可以理解同步代码块和同步方法的锁对象问题，但是我们并没有直接看到在哪里加上了锁，在哪里释放了 锁，为了更清晰的表达如何加锁和释放锁，JDK5以后提供了一个新的锁对象Lock Lock是接口不能直接实例化，这里采用它的实现类ReentrantLock来实例化。

      • ReentrantLock() 创建一个ReentrantLock的实例

      • lick() 获得锁

      • unlock() 释放锁

      • 买票代码示例：【三个窗口同时卖100张票】

        public class SellTicket implements Runnable {
private int tickets = 100;
    //创建对象
private Lock lock = new ReentrantLock();
@Override
public void run() {
while (true) {
try {
    //上锁
lock.lock();
if (tickets > 0) {
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
System.out.println(Thread.currentThread().getName() + "正在出售
第" + tickets + "张票");
tickets--;
}
} finally {
    //解锁
lock.unlock();
}
}
}
}
public class SellTicketDemo {
public static void main(String[] args) {
SellTicket st = new SellTicket();
Thread t1 = new Thread(st, "窗口1");
Thread t2 = new Thread(st, "窗口2");
Thread t3 = new Thread(st, "窗口3");
t1.start();
t2.start();
t3.start();
}
}

  • 死锁：当多个线程共享一个资源的时候需要进行同步，但是过多的同步可能导致死锁：即当两个或两个以上的线程在执行过程中，因争夺资源造成了互相等待，并且若无外力作用，它们都将无法推进下去的现象称为系统处在死锁状态或系统产生了死锁。

    • 出现死锁的情况：
      • 相互排斥：一个线程永远占用某一共享资源。
      • 循环等待：线程A在等待线程B，线程B在等待线程C，线程C在等待线程A。
      • 部分分配：线程A得到了资源一，线程B得到了资源二，两个线程都不能得到全部的资源。
      • 缺少优先权：一个线程访问了某资源，但一直不释放该资源，即使该线程处于阻塞状态。

常见线程同步案例

生产者消费者示例1：

【使用多线程实现随机生产和消费标有26个大写字母的球，生产出的球放入容量为5的箱子里并从该箱子中消费，要求生产球的总量为10个】

//盒子
public class Box {
    private int index = 0;
    private char[] container = new char[5];

    public synchronized void push(char c) {
        //判断盒子是否盛满
        //之前一直以为，线程如果被唤醒后再次执行时，会从头开始运行这个线程，也就是重新运行Runnable中的run()方法；
        //而实际情况是，被唤醒并且被执行的线程是从上次阻塞的位置从下开始运行，也就是从wait()方法后开始执行。
        //所以判断是否进入某一线程的条件 是用while判断，而不是用If判断判断。
        while (index == container.length) {
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        //把球放入箱子中
        container[index] = c;
        index++;
        //唤醒等待的消费者
        this.notify();
    }

    public synchronized char pop() {
        //判断盒子是否为空
        while (index == 0) {
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        //消费球
        index--;
        char c = container[index];
        //唤醒等待的生产者
        this.notify();
        //返回消费的球
        return c;
    }
}

//生产者

public void run() {
        for (int i = 0; i < 10; i++) {
            char c = (char) ((int) (Math.random() * 26) + 'A');
            box.push(c);
            System.out.println("生产者" + Thread.currentThread().getName() + "生产了名子为" + c + "的球");
            try {
                Thread.sleep(2000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}


//消费者
public class Consumer implements Runnable {
    Box box;

    public Consumer(Box box) {
        this.box = box;
    }

    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            char c = box.pop();
            System.out.println("消费者" + Thread.currentThread().getName() + "消费了名字为" + c + "的球");
            try {
                Thread.sleep((int) (Math.random() * 1000));
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}


//测试
public class Test {
    public static void main(String[] args) {
        Box box = new Box();
        Producer p = new Producer(box);
        Consumer c = new Consumer(box);
        Thread p1 = new Thread(p);
        p1.setName("P1");
        Thread c1 = new Thread(c);
        c1.setName("c1");
        c1.start();
        p1.start();
    }
}

生产者消费者示例2

【案例需求：】

生产者消费者案例中包含的类：
奶箱类(Box)：定义一个成员变量，表示第x瓶奶，提供存储牛奶和获取牛奶的操作
生产者类(Producer)：实现Runnable接口，重写run()方法，调用存储牛奶的操作
消费者类(Customer)：实现Runnable接口，重写run()方法，调用获取牛奶的操作
测试类(BoxDemo)：里面有main方法，main方法中的代码步骤如下
①创建奶箱对象，这是共享数据区域
②创建消费者创建生产者对象，把奶箱对象作为构造方法参数传递，因为在这个类中要调用存储牛奶的操作
③对象，把奶箱对象作为构造方法参数传递，因为在这个类中要调用获取牛奶的操作
④创建2个线程对象，分别把生产者对象和消费者对象作为构造方法参数传递
⑤启动线程

public class Box {
//定义一个成员变量，表示第x瓶奶
private int milk;
//定义一个成员变量，表示奶箱的状态
private boolean state = false;
//提供存储牛奶和获取牛奶的操作
public synchronized void put(int milk) {
//如果有牛奶，等待消费
if(state) {
try {
wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
//如果没有牛奶，就生产牛奶
this.milk = milk;
System.out.println("送奶工将第" + this.milk + "瓶奶放入奶箱");
//生产完毕之后，修改奶箱状态
state = true;
//唤醒其他等待的线程
notifyAll();
}
public synchronized void get() {
//如果没有牛奶，等待生产
if(!state) {
try {
wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
//如果有牛奶，就消费牛奶
System.out.println("用户拿到第" + this.milk + "瓶奶");
//消费完毕之后，修改奶箱状态
state = false;
//唤醒其他等待的线程
notifyAll();
}
}


public class Producer implements Runnable {
private Box b;
public Producer(Box b) {
this.b = b;
}
@Override
public void run() {
for(int i=1; i<=30; i++) {
b.put(i);
}
}
}


public class Customer implements Runnable {
private Box b;
public Customer(Box b) {
this.b = b;
}
@Override
public void run() {
while (true) {
b.get();
}
}
}

public class BoxDemo {
public static void main(String[] args) {
//创建奶箱对象，这是共享数据区域
Box b = new Box();
//创建生产者对象，把奶箱对象作为构造方法参数传递，因为在这个类中要调用存储牛奶的操作
Producer p = new Producer(b);
//创建消费者对象，把奶箱对象作为构造方法参数传递，因为在这个类中要调用获取牛奶的操作
Customer c = new Customer(b);
//创建2个线程对象，分别把生产者对象和消费者对象作为构造方法参数传递
Thread t1 = new Thread(p);
Thread t2 = new Thread(c);
//启动线程
t1.start();
t2.start();
}

卖票示例

【某电影院目前正在上映国产大片，共有100张票，而它有3个窗口卖票，请设计一个程序模拟该电影院卖票】

//卖票
public class SellTicket implements Runnable {
    private int ticket = 100;

    @Override
    public void run() {
        while (true) {
            synchronized (this) {
                if (ticket > 0) {
                    System.out.println(Thread.currentThread().getName() + "卖出了第" + ticket + "张票");
                    ticket--;
                }
            }
            //这里加sleep的原因：
            //第一是为了还原现实中卖票的中间空闲时刻
            //第二是因为如果不设置等待时间，同等优先权的线程中竞争cup执行同一个程序，为了提高cpu的效率就默认不切换线程。几乎不会出现多线程的效果

            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

    }
}

public class BoxDemo {
public static void main(String[] args) {
//创建奶箱对象，这是共享数据区域
Box b = new Box();
//创建生产者对象，把奶箱对象作为构造方法参数传递，因为在这个类中要调用存储牛奶的操作
Producer p = new Producer(b);
//创建消费者对象，把奶箱对象作为构造方法参数传递，因为在这个类中要调用获取牛奶的操作
Customer c = new Customer(b);
//创建2个线程对象，分别把生产者对象和消费者对象作为构造方法参数传递
Thread t1 = new Thread(p);
Thread t2 = new Thread(c);
//启动线程
t1.start();
t2.start();
}
}

车间玩具制造示例

【题目描述】

创建工厂类，

属性包括：车间类的对象的集合，仓库容量

方法包括：

    1. 加工玩具的方法(product)，方法的功能是各个车间同时工作。根据仓库容量平均分配给各个车间需要加工玩具的数量。

    2. 建造玩具车间的方法(createWorkshop)，方法功能是模拟建造玩具生成车间，即向集合属性中添加一个新车间。

创建车间类：

属性包括：车间名称

要求：

1. 使用多线程模拟加工玩具的功能，假设每隔2秒可完成一个玩具的加工，每个车间完成一个玩具的加工后，打印当前已加工玩具数量（给每个线程设置名称为车间的名称）

2. 创建测试类，模拟工厂加工玩具的功能。

提示：车间集合的容量即是线程的数量

//工厂类
public class Factory {
    private List<Workshop> list = new ArrayList<Workshop>();
    private int capacity;

    public Factory() {
    }

    public Factory(int capacity) {
        this.capacity = capacity;
    }

    public void product() {
        int i = 1;
        int num = capacity / list.size();
        Workshop.setNum(num);
        for (Workshop workshop : list) {
            Thread t = new Thread(workshop);
            t.setName("车间" + i);
            i++;
            t.start();
        }
    }

    public void createWorkshop(String name) {
        Workshop workshop = new Workshop(name);
        list.add(workshop);
    }
}
//车间类
public class Workshop implements Runnable {
    private static int num;
    public String name;

    public Workshop() {
    }

    public Workshop(String name) {
        this.name = name;
    }

    public static int getNum() {
        return num;
    }

    public static void setNum(int num) {
        Workshop.num = num;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public void run() {
        synchronized (Thread.currentThread()) {
            for (int i = 1; i <= num; i++) {
                System.out.println(Thread.currentThread().getName() + "生产了第" + i + "个玩具");
                try {
                    Thread.sleep(2000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}
//测试类
public class Test {
    public static void main(String[] args) {
        Factory factory = new Factory(100);
        for (int i = 0; i < 5; i++) {
            factory.createWorkshop("车间" + i);
        }
        factory.product();
    }
}
Sheep6erder
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Java多线程-多线程知识点总结和企业真题
02-04
Java多线程--多线程知识点总结和企业真题
关于多线程的经典案例~
qq_57603004的博客
04-06 2955
关于多线程的案例
线程中断以及线程中断引发的那些问题
weixin_34309435的博客
09-10 620
什么是线程中断？ 在我们的Java程序中其实有不止一条执行线程，只有当所有的线程都运行结束的时候，这个Java程序才算运行结束。 官方的话给你描述一下：当所有的非守护线程运行结束时，或者其中一个线程调用了System.exit()方法时，这个Java程序才能运行结束。 线程中断的应用场景 我们先来举一个例子，比如我们现在在下载一个500多M的大片，我们点...
pytest多进程/多线程执行测试用例
weixin_45005677的博客
07-04 5931
利用多进程/多线程并行执行测试用例，提升测试执行效率。
Java多线程模拟加工厂加工玩具
m0_48792508的博客
03-30 597
创建工厂类， 属性包括：车间类的对象的集合，仓库容量 方法包括： 1. 加工玩具的方法(product)，方法的功能是各个车间同时工作。根据仓库容量平均分配给各个车间需要加工玩具的数量。 2. 建造玩具车间的方法(createWorkshop)，方法功能是模拟建造玩具生成车间，即向集合属性中添加一个新车间。 创建车间类： 属性包括：车间名称 要求： 1. 使用多线程模拟加工玩具的功能，假设每隔2秒可完成一个玩具的加工，每个车间完成一个玩具的加工后，打印当前已加工玩具数量（给每个线程设置名称为车间的名称）
编写多线程并发的测试类
飞血泪无痕的博客
09-24 8489
在实际运用的过程中，我们经常遇到一些场景需要测试我们接口的并发能力。 案例： 1.一个抽奖接口，在奖品被抽完后总不能还继续中到此奖品吧，万一是iphone等大奖，那就悲剧需要写邮件反省了。 2.一个下订单接口，用户要是操作速度或者网速的原因导致两个请求同时到达服务器，难道就插入两条订单么？同样，说不定还得邮件反省。 事由： 1.集群分布式部署导致synchroni
Java多线程-知识点梳理和总结-超详细-面试知识点.docx
12-17
Java多线程-知识点梳理和总结-超详细-面试知识点.docx
IOS开发-多线程队列测试代码
01-04
// 单线程和多线程并发队列测试(同步和异步) // // 基础原理： // 1)队列： // 1.1 dispatch_queue_t 是一个队列,一个FIFO的消费队列 // 1.2 消费者：队列配置的运行线程 // 1.3 被消费对象: 添加到队列中的运行任务...
多线程相关知识源码-----多线程案例源码
07-15
多线程相关知识源码-----多线程案例源码
JAVA-多线程 所有文件
01-09
JAVA-多线程 所有文件
java多线程测试实例
02-08
在实际项目中 多线程用的比较广泛 本人根据网络资源整理出了一个小小的多线程实例 大家有需要可以下载
多线程测试
09-21
测试多线程的实现方式，并且和单线程进行比较，可以让初学者更快的理解线程机制的好处
测试方向基础———多线程浅析
m0_51508220的博客
03-30 786
线程简介 java创建多线程 同步金额死锁
多线程应用的测试与调试
人无远虑，必有近忧
06-22 1193
测试和调试就相当于一个硬币的两面——测试代码寻找错误，调试代码纠正错误。幸运的话，你自己调试出所有的错误，而不是让使用该应用的人发现代码漏洞。在我们介绍测试和调试之前，重要的是理解可能会出现哪些问题，让我们先来看看这些问题。 ...
多线程实例（自己测试的）
weixin_38166557的博客
07-15 213
多线程首先要：1.继承Thread类 2.实现Runable接口 3.复写run()方法 1.继承Thread类需要在run()方法上添加@Override 注解 2.实现Runable接口不需要添加@Override 注解 转载于:https://www.cnblogs.com/mark5/p/11190537.html...
java中的多线程实例
09-04 408
在java中要想实现多线程，有两种手段，一种是继续Thread类，另外一种是实现Runable接口。 对于直接继承Thread的类来说，代码大致框架是： view sourceprint? 01    class 类名 extends Thread{ 02    方法
多线程测试（一）
weixin_51368761的博客
11-07 1892
编写一个ThreadTest类，分别通过继承Thread类和实现Runnable接口，两种方式实现两个线程。 两个线程执行的任务是实现同一个变量 count 的累加操作，count从1增加到10，每增加1， 在控制台输出 " 执行累加操作的线程的线程名+count 变量的值，输出后该线程 休眠1秒，测试线程操作的相关方法（包括 sleep，interrupt，join）。 思路分析：①首先要建立两个线程，一个是继承Thread，另一个是实现Runnable接口（其实两者的本质是一样的，Thread就是实现了
Java多线程做压力测试
weixin_34026484的博客
04-11 383
2019独角兽企业重金招聘Python工程师标准>>> ...
TestNg多线程—— 并行执行测试
DreamTL的博客
12-22 9596
多线程并行执行测试，可以通过参数设置来实现不同级别的多线程配置测试 1、test级别的多线程测试，每个标签下的所有方法将在同一个线程中执行，不同的是在不同的线程来运行的。修改配置如下： 其中thread-count 表示启动的线程数  ， parallel 参数用例定义平行化的级别： 备注： 当前测试规划的执行过程中，为每个测试用例的执行使用单独的线程，最多并发2
python多线程爬虫大作业-Python多线程爬虫简单示例
最新发布
05-16
好的，以下是一个简单的多线程爬虫示例： ```python import requests import threading from queue import Queue # 定义一个类，继承 threading.Thread 类 class CrawlerThread(threading.Thread): def __init__...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值