【Java】【多线程常见面试题】

最新推荐文章于 2024-07-05 22:28:16 发布
最新推荐文章于 2024-07-05 22:28:16 发布
阅读量275 收藏
点赞数
分类专栏： 【java】
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/lzm18064126848/article/details/68952871
版权

1.子线程循环 10 次，接着主线程循环 100 次，接着又回到子线程循环 10 次，接着再回到主线程又循环 100 次，如此循环50次，试写出代码

package Test;

public class Test {
    static class Business{
        private boolean Substop=false;

        public synchronized void sub(int i){
            while(Substop){
                try {
                    this.wait();
                }catch (InterruptedException e){
                    e.printStackTrace();
                }
            }
            for (int j = 0; j <10 ; j++) {
                System.out.println("sub run"+j+"in round"+i);
            }
            Substop=true;
            this.notifyAll();
        }
        public synchronized void main(int i){
            while (!Substop){
                try {
                    this.wait();
                }catch (InterruptedException e){
                    e.printStackTrace();
                }
            }
            for (int j = 0; j <100 ; j++) {
                System.out.println("main run"+j+"in round"+i);
            }
            Substop=false;
            this.notifyAll();
        }
    }

    public static void main(String[]  args){
        final Business business=new Business();
        for (int i = 0; i <50 ; i++) {
            final int fi=i;
            new Thread(new Runnable() {
                @Override
                public void run() {
                   // business.sub(i);     报错  只能访问方法中定义的final类型的局部变量
                    business.sub(fi);  //当一个对象获取对象锁的时候 其另外的同步方法都会暂停执行
                }
            }).start();
            business.main(fi);
        }
    }
}



package Test;

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

public class Test {
    static class Business{
        Lock lock=new ReentrantLock();
        Condition condition=lock.newCondition();
        private boolean Substop=false;
        public  void sub(int i){
            lock.lock();
            try{
                while(Substop){
                    try {
                        condition.await();
                    }catch (InterruptedException e){
                        e.printStackTrace();
                    }
                }
                for (int j = 0; j <10 ; j++) {
                    System.out.println("sub run"+j+"in round"+i);
                }
                Substop=true;
                condition.signalAll();
            }catch (Exception e){
                e.printStackTrace();
            }finally {
                lock.unlock();
            }

        }
        public  void main(int i){
            lock.lock();
            try {
                while (!Substop){
                    try {
                       condition.await();
                    }catch (InterruptedException e){
                        e.printStackTrace();
                    }
                }
                for (int j = 0; j <100 ; j++) {
                    System.out.println("main run"+j+"in round"+i);
                }
                Substop=false;
                condition.signalAll();
            }catch (Exception e){
                    e.printStackTrace();
            }finally {
                lock.unlock();
            }

        }
    }

    public static void main(String[]  args){
        final Business business=new Business();
        for (int i = 0; i <50 ; i++) {
            final int fi=i;
            new Thread(new Runnable() {
                @Override
                public void run() {
                   // business.sub(i);     报错  只能访问方法中定义的final类型的局部变量
                    business.sub(fi);  //当一个对象获取对象锁的时候 其另外的同步方法都会暂停执行
                }
            }).start();
            business.main(fi);
        }
    }
}


package Test;

import java.util.concurrent.BlockingDeque;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class Test {
    static class Business{
      LinkedBlockingQueue<Integer> queue1=new LinkedBlockingQueue<>(1);
      LinkedBlockingQueue<Integer>  queue2=new LinkedBlockingQueue<>(1);

      {
            try{
                queue2.put(1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
      }

        public  void sub(int i){
            try{
                queue1.put(1);
            } catch (InterruptedException e1) {
                e1.printStackTrace();
            }
            for (int j = 0; j <10 ; j++) {
                    System.out.println("sub run"+j+"in round"+i);
                }
            try {
                queue2.take();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        public  void main(int i){
            try{
                queue2.put(1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            for (int j = 0; j <99 ; j++) {
                System.out.println("main run " + j + " in round " + i);
            }
            try{
                queue1.take();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    public static void main(String[]  args){
        final Business business=new Business();
        for (int i = 0; i <50 ; i++) {
            final int fi=i;
            new Thread(new Runnable() {
                @Override
                public void run() {
                   // business.sub(i);     报错  只能访问方法中定义的final类型的局部变量
                    business.sub(fi);  //当一个对象获取对象锁的时候 其另外的同步方法都会暂停执行
                }
            }).start();
            business.main(fi);
        }
    }
}


2.编写一个程序，开启3个线程，这3个线程的ID分别为A、B、C，每个线程将自己的ID在屏幕上打印10遍，要求输出结果必须按ABC的顺序显示；如：ABCABC

package Test;

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

public class Test{
    static class Innerclass{
        Lock  lock=new ReentrantLock();
        Condition conditionA=lock.newCondition();
        Condition conditionB=lock.newCondition();
        Condition conditionC=lock.newCondition();
        private String name="A";

        public void printA(){
            lock.lock();
            try {
                if (!name.equals("A")){
                    conditionA.await();
                }
                System.out.print(Thread.currentThread().getName());
                Thread.sleep(1000);
                name="B";
                conditionB.signal();
            }catch (Exception e){
                e.printStackTrace();
            }finally {
                lock.unlock();
            }

        }
        public void printB(){
            lock.lock();
            try {
                if (!name.equals("B")){
                    conditionB.await();
                }
                System.out.print(Thread.currentThread().getName());
                Thread.sleep(1000);
                name="C";
                conditionC.signal();
            }catch (Exception e){
                e.printStackTrace();
            }finally {
                lock.unlock();
            }

        }
        public void printC(){
            lock.lock();
            try {
                if (!name.equals("C")){
                    conditionC.await();
                }
                System.out.print(Thread.currentThread().getName());
                Thread.sleep(1000);
                name="A";
                conditionA.signal();
            }catch (Exception e){
                e.printStackTrace();
            }finally {
                lock.unlock();
            }

        }
    }

    public static void init(){
        final Innerclass innerclass=new Innerclass();
        Thread thread=new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i <10 ; i++) {
                    innerclass.printA();
                }
            }
        });
        thread.setName("A");

      Thread thread2=new Thread(new Runnable() {
          @Override
          public void run() {
              for (int i = 0; i <10 ; i++) {
                  innerclass.printB();
              }
          }
      });
      thread2.setName("B");

        Thread thread3=new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i <10 ; i++) {
                    innerclass.printC();
                }
            }
        });
        thread3.setName("C");

        thread.start();
        thread2.start();
        thread3.start();
    }

    public static void main(String[] args) {
        Test test=new Test();
        test.init();
    }
}



circujoker_06
关注
专栏目录
Java多线程常用面试题(含答案,精心总结整理)
乌枭的博客
11-03 9210
Java并发编程问题是面试过程中很容易遇到的问题，提前准备是解决问题的最好办法，将试题总结起来，时常查看会有奇效。
java中关于线程的常见面试题
BAO452567228的博客
12-25 777
1、什么是线程? 线程是操作系统能够进行运算调度的最小单位，它被包含在进程之中，是进程中的实际运作单位。程序员可以通过它进行多处理器编程，你可以使用多线程对运算密集型任务提速。比如，如果一个线程完成一个任务要100毫秒，那么用十个线程完成改任务只需10毫秒。 2、线程和进程有什么区别? 线程是进程的子集，一个进程可以有很多线程，每条线程并行执行不同的任务。不同的进程使用不
15 个 Java 线程面试题和答案
修身、齐家、治国、平天下！
04-08 716
下面是各种投行，比如巴克莱银行（Barclays）、花旗银行（Citibank）、摩根史坦利投资公司（Morgan Stanley）等等，面试 Java 开发者时常问的 Java 多线程和并发问题。 1. 现在有线程 T1、T2 和 T3。你如何确保 T2 线程在 T1 之后执行，并且 T3 线程在 T2 之后执行？ 这个线程面试题通常在第一轮面试或电话面试时被问到，这道多线程问题为了测试面试...
多线程的理解
ArcticOcean's blog
09-21 470
1:多线程有几种实现方案，分别是哪几种? 两种。 继承Thread类 实现Runnable接口 扩展一种：实现Callable接口。这个得和线程池结合。 2:同步有几种方式，分别是什么? 两种。 同步代码块 同步方法 3:启动一个线程是run()还是start()?它们的区别? start(); run():封装了被线程执行的代码,直接调用仅仅
JAVA多线程面试题及答案
lixiaoxiong的专栏
08-11 5780
这篇文章主要是对多线程的问题进行总结的，因此罗列了40个多线程的问题。 这些多线程的问题，有些来源于各大网站、有些来源于自己的思考。可能有些问题网上有、可能有些问题对应的答案也有、也可能有些各位网友也都看过，但是本文写作的重心就是所有的问题都会按照自己的理解回答一遍，不会去看网上的答案，因此可能有些问题讲的不对，能指正的希望大家不吝指教。   1、多线程有什么用？ 一个可能在很多人看来...
Java多线程常见面试题
SileeLiu的博客
04-16 1万+
1. 并行和并发有什么区别？ 并行（Parallel）：指两个或者多个事件在同一时刻发生，即同时做不同事的能力。例如垃圾回收时，多条垃圾收集线程并行工作，但此时用户线程仍然处于等待状态。 并发（Concurrent）：指两个或多个事件在同一时间间隔内发生，即交替做不同事的能力，多线程是并发的一种形式。例如垃圾回收时，用户线程与垃圾收集线程同时执行（但不一定是并行的，可能会交替执行），用户程序在继...
Java多线程相关面试题整理
最新发布
是袁同学呀
07-05 2140
个人闲暇时整理的Java并发编程相关问题，偏向于常见面试题总结，非系统的知识理解，不适合零基础。个人知识有限，如有遗漏欢迎补充。
java中多线程常见面试题
libaowenBlog的博客
06-07 1万+
线程池本质上是一种池化技术，而池化技术是一种资源复用的思想，比较常见的有连接池、内存池、对象池。减少线程的频繁创建和销毁带来的性能开销，因为线程创建会涉及到CPU上下文切换、内存分配等工作。 线程池本身会有参数来控制线程创建的数量，这样就可以避免无休止的创建线程带来的资源利用率过高的问题， 起到了资源保护的作用。 线程池参数七大参数corePoolsize 核心线程数：正常情况下创建的工作的线程数，这些线程创建后并不会立马消除，一种常驻住线程maxinumPoolSize 最大线程数：表示允许创建的最大线
java多线程面试题59题集合
03-15
以下是对Java多线程面试题59题集合中可能涉及的一些关键知识点的详细解析。 1. **线程的创建方式** - 继承Thread类：创建一个新的类，该类继承自Thread类，并重写其run()方法。 - 实现Runnable接口：创建一个实现...
面试-Java一些常见面试题+题解之多线程开发-JavaConcurrent.zip
03-03
本资料集合了Java面试中与多线程相关的常见问题及解答，旨在帮助求职者充分准备这一关键领域的知识。 1. **线程的概念与创建** - 线程是程序执行的最小单位，一个进程可以包含多个线程。 - Java中创建线程有两种...
一文读懂物联网 MQTT 协议之基础特性篇，java多线程常见面试题
2401_83621384的博客
03-20 755
LastWillxxx 表示的是遗愿，client 在连接 broker 的时候将会设立一个遗愿，这个遗愿会保存在 broker 中，当 client 因为非正常原因断开与 broker 的连接时，broker 会将遗愿发送给订阅了这个 topic（订阅遗愿的 topic）的 client。Broker 负责接收所有消息，过滤消息，确定是哪个Client 订阅了每条消息，并将消息发送给对应的 Client，Broker 还负责保存会话数据，这些数据包括订阅的和错过的消息。负载分布在队列的所有消费者之间。
Java多线程常用面试题
巴卡巴卡哇的博客
10-09 1万+
一、什么是多线程？ 线程是指程序在运行的过程中，能够执行程序代码的一个执行单元。 Java语言中，线程有五种状态：新建、就绪、运行、阻塞及死亡。 二、线程与进程的区别？ 进程是指一段正在执行的程序。而线程有时也被称为轻量级进程，它是程序执行的最小单元，一个进程可以拥有多个线程，各个线程之间共享程序的内存空间（代码段、数据段、堆空间）及一些...
【java】this()与super()使用详解
热门推荐
lzm18064126848的专栏
07-26 2万+
package test; public class ThisTest {     private int i=0;     //第一个构造器：有一个int型形参     ThisTest(int i){                 System.out.println("i:"+this.i);                this.i=i+1;//此时th
【java】【java8】Lambda、Stream、Function、Consumer、Predicate、Supplier
lzm18064126848的专栏
04-16 9806
Function源代码 package java.util.function; import java.util.Objects; /** * Represents a function that accepts one argument and produces a result. * * This is a functional interface whose functional
【java】BigDecimal、BigInteger、大数相乘、数值的整数次方、快速乘法
lzm18064126848的专栏
03-23 4389
package Test; import java.math.BigDecimal; public class Test { public static void main(String[] args){ double d1=2.15; double d2=1.10; System.out.println("double运行的结果："
【java】深入理解getClass()
lzm18064126848的专栏
12-27 3844
之所以标题写的是深入理解，主要是为了让更多人能够惯性思维的以为我这个是一篇好文。事情的真相是我只是为了和网络上面很多抄来抄去的做一下区分而已，自己遇到这个问题的时候，也是百度、google，发现很多文章都是一样的，很多细节性的错误暗示作者可能连起码的代码都没有运行。我自己相比于他们多的就是多看几篇，多运行几遍代码，然后整理一下思路，主要目的是为了将来自己忘记了再回过来看的时候能够一目了然，这也是我
【java】多线程中Thread.currentThread().getName()和this.getName()的区别
lzm18064126848的专栏
01-04 2096
参考文章： http://www.cnblogs.com/huangyichun/p/6071625.html 程序一： public class Run1 { public static void main(String[] args) { System.out.println(Thread.currentThread().getName()); //main方
java多线程常见面试题
09-15
Java多线程常见面试题包括以下几个方面： 1. 什么是线程和进程，它们有什么区别？ 2. 如何创建线程？有几种方式可以实现多线程？ 3. 什么是线程安全？如何保证线程安全？ 4. 什么是线程同步？有哪些常见的线程同步...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值