Java面试知识点：多线程

最新推荐文章于 2023-04-27 00:45:08 发布
最新推荐文章于 2023-04-27 00:45:08 发布
阅读量268 收藏
点赞数
分类专栏： JAVA 文章标签： java 面试
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yang13563758128/article/details/120062091
版权

问题：Java面试知识点：多线程

答案：

1.线程

 代码如下：

package com.xy;

/**
 * @ProjectName: day01
 * @Package: com.xy
 * @ClassName: test01
 * @Author: 杨路恒
 * @Description:
 * @Date: 2021/8/25 0025 16:57
 * @Version: 1.0
 */
public class test01 {
    public static void main(String[] args) {
        MyThread myThread=new MyThread();
        MyThread myThread1=new MyThread();
        myThread.start();
        myThread1.start();
    }
}




public class test02 {
    public static void main(String[] args) {
        MyRunnable mr=new MyRunnable();     //创建了一个参数对象
        Thread t=new Thread(mr);            //创建了一个线程对象，并把参数传递给这个线程
        t.start();
        MyRunnable mr1=new MyRunnable();
        Thread t1=new Thread(mr1);            //创建了一个线程对象，并把参数传递给这个线程
        t1.start();
    }
}

public class MyRunnable implements Runnable {
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.println("第二种方式启动线程"+i);
        }

    }
}





public class test03 {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        MyCallable mc=new MyCallable();     //线程开启之后需要执行里面的call方法
        //可以获取线程执完毕之后的结果，也可以作为参数传递给Thread对象
        FutureTask<String> ft=new FutureTask<>(mc);
        Thread t=new Thread(ft);
        System.out.println(t.getName());
        t.start();
        String s = ft.get();
        System.out.println(s);
        MyCallable mc1=new MyCallable();     //线程开启之后需要执行里面的call方法
        //可以获取线程执完毕之后的结果，也可以作为参数传递给Thread对象
        FutureTask<String> ft1=new FutureTask<>(mc);
//        Thread t1=new Thread(ft,"恒大大");
        Thread t1=new Thread(ft);
        t1.start();
        t1.setName("杨大大");
        System.out.println(t1.getName());
        String s1 = ft.get();
        System.out.println(s);

    }
}

public class MyCallable implements Callable<String> {
    @Override
    public String call() throws Exception {
        for (int i = 0; i < 100; i++) {
            System.out.println("第三种启动线程方式"+i);
            Thread.sleep(1000);
        }
        return "成功";
    }
}

2.同步代码块、同步方法

代码如下：

public class test04 {
    public static void main(String[] args) {
        MyRunnable1 mr=new MyRunnable1();
        Thread t=new Thread(mr);
        Thread t1=new Thread(mr);
        Thread t2=new Thread(mr);
        t.start();
        t1.start();
        t2.start();
    }

}
class MyRunnable1 implements Runnable{
    private int ticket=100;
    Object obj=new Object();
    @Override
    public void run() {
        while (true){
            synchronized (obj){         //同步代码块
                if (ticket>0){
                    System.out.println(Thread.currentThread().getName()+"卖第"+ticket+"张票");
                    ticket--;
                }
                else {
                    return;
                }
            }
        }
    }
}

package com.xy;

/**
 * @ProjectName: day01
 * @Package: com.xy
 * @ClassName: test04
 * @Author: 杨路恒
 * @Description:
 * @Date: 2021/8/26 0026 16:51
 * @Version: 1.0
 */
public class test05 {
    public static void main(String[] args) {
        MyRunnable2 mr = new MyRunnable2();
        Thread t = new Thread(mr);
        Thread t1 = new Thread(mr);
        Thread t2 = new Thread(mr);
        t.start();
        t1.start();
        t2.start();
    }

}

class MyRunnable2 implements Runnable {
    private int ticket = 100;
    Object obj = new Object();

    @Override
    public void run() {
        while (true) {
            ticket();
        }
    }

    public synchronized void ticket() {
        if (ticket > 0) {
            System.out.println(Thread.currentThread().getName() + "卖第" + ticket + "张票");
            ticket--;
        } else {
            return;
        }
    }
}

3.原子性、CAS算法

 代码如下：

package com.xy;

import java.util.concurrent.atomic.AtomicInteger;

/**
 * @ProjectName: day01
 * @Package: com.xy
 * @ClassName: test16原子性
 * @Author: 杨路恒
 * @Description:
 * @Date: 2021/8/29 0029 14:08
 * @Version: 1.0
 */
public class test16原子性 {
    public static void main(String[] args) {
        AtomicInteger ac=new AtomicInteger();
        System.out.println(ac);
        AtomicInteger ac1=new AtomicInteger(6);
        System.out.println(ac1);
    }
}



package com.xy;

import java.util.concurrent.atomic.AtomicInteger;

/**
 * @ProjectName: day01
 * @Package: com.xy
 * @ClassName: test17原子性
 * @Author: 杨路恒
 * @Description:
 * @Date: 2021/8/29 0029 14:10
 * @Version: 1.0
 */
public class test17原子性 {
    public static void main(String[] args) {
        AtomicInteger ac=new AtomicInteger(6);
        System.out.println(ac.get());
        int i = ac.getAndIncrement();
        int i1 = ac.incrementAndGet();
        System.out.println(i);
        System.out.println(i1);
        int i2 = ac.addAndGet(6);
        System.out.println(i2);
        int i3 = ac.getAndSet(6);
        System.out.println(i);
    }
}

4.线程池

 代码如下：

package com.xy;

import java.util.concurrent.Executor;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

/**
 * @ProjectName: day01
 * @Package: com.xy
 * @ClassName: test10线程池
 * @Author: 杨路恒
 * @Description:
 * @Date: 2021/8/27 0027 19:54
 * @Version: 1.0
 */
public class test10线程池 {
    public static void main(String[] args) throws InterruptedException {
        ExecutorService executorService= Executors.newCachedThreadPool();
        executorService.submit(()->{
            System.out.println(Thread.currentThread().getName()+"启动");
        });
        Thread.sleep(2000);
        executorService.submit(()->{
            System.out.println(Thread.currentThread().getName()+"启动");
        });
        Thread.sleep(2000);
        executorService.shutdown(); 
    }
}





public class test13线程池 {
    public static void main(String[] args) {
        ThreadPoolExecutor pool=new ThreadPoolExecutor(2,
                5,2,
                TimeUnit.SECONDS,new ArrayBlockingQueue<>(10),
                Executors.defaultThreadFactory(),new ThreadPoolExecutor.AbortPolicy());
        pool.submit(new MyRunnable3());
        pool.submit(new MyRunnable3());
        pool.shutdown();
    }
}



public class test14线程池 {
    public static void main(String[] args) {
        ThreadPoolExecutor pool=new ThreadPoolExecutor(1,
                2,2,
                TimeUnit.SECONDS,new ArrayBlockingQueue<>(1),
                Executors.defaultThreadFactory(),
//                new ThreadPoolExecutor.AbortPolicy());
//                new ThreadPoolExecutor.DiscardPolicy());
//                new ThreadPoolExecutor.DiscardOldestPolicy());
                new ThreadPoolExecutor.CallerRunsPolicy());
        for (int i = 0; i < 5; i++) {
            int y=i;
            pool.submit(()->{
                System.out.println(Thread.currentThread().getName()+":"+y);
            });
        }
        pool.shutdown();
    }
}

5.阻塞队列

代码如下：

public class test08阻塞队列 {
    public static void main(String[] args) {
        ArrayBlockingQueue<String> list=new ArrayBlockingQueue<>(1);

        Cooker1 c=new Cooker1(list);
        Foodie1 f=new Foodie1(list);
        c.start();
        f.start();
    }
}



public class test09阻塞队列 {
    public static void main(String[] args) throws InterruptedException {
        ArrayBlockingQueue<String> list=new ArrayBlockingQueue<>(1);
        list.put("汉堡包");
        System.out.println(list.take());
    }
}



public class Cooker1 extends Thread{
    ArrayBlockingQueue<String> list;

    public Cooker1(ArrayBlockingQueue<String> list) {
        this.list = list;
    }

    @Override
    public void run() {
        while (true){
            try {
                list.put("汉堡包");
                System.out.println("生产者");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

public class Foodie1 extends Thread{
    ArrayBlockingQueue<String> list;

    public Foodie1(ArrayBlockingQueue<String> list) {
        this.list = list;
    }

    @Override
    public void run() {
        while (true){
            try {
                String take = list.take();
                System.out.println("消费者");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

生产者、消费者：

public class Cooker extends Thread {
    private Desk desk;
    public Cooker(Desk desk) {

    }

    @Override
    public void run() {
        while (true){
            synchronized (desk.getLock()){
                if (desk.getCount()==0){
                    break;
                }
                else {
                    if (!desk.isFlag()){
                        System.out.println("生产者");
                        desk.setFlag(true);
                        desk.getLock().notifyAll();
                    }
                    else {
                        try {
                            desk.getLock().wait();
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                }
            }
        }
    }
}



public class Desk {
    private boolean flag=false;
    private int count=100;
    private final Object lock=new Object();

    public boolean isFlag() {
        return flag;
    }

    public void setFlag(boolean flag) {
        this.flag = flag;
    }

    public int getCount() {
        return count;
    }

    public void setCount(int count) {
        this.count = count;
    }

    public Object getLock() {
        return lock;
    }

    @Override
    public String toString() {
        return "Desk{" +
                "flag=" + flag +
                ", count=" + count +
                ", lock=" + lock +
                '}';
    }

    public Desk(boolean flag, int count) {
        this.flag = flag;
        this.count = count;
    }

    public Desk() {
        this(true,100);
    }
}



public class Foodie extends Thread{

    private Desk desk;

    public Foodie(Desk desk) {

    }

    @Override
    public void run() {
        while (true){
            synchronized (desk.getLock()){
                if (desk.getCount()==0){
                    break;
                }
                else {
                    if (desk.isFlag()){
                        System.out.println("消费者");
                        desk.setFlag(false);
                        desk.getLock().notifyAll();
                        desk.setCount(desk.getCount()-1);
                    }
                    else {
                        try {
                            desk.getLock().wait();
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                }
            }
        }
    }
}

package com.xy;

/**
 * @ProjectName: day01
 * @Package: com.xy
 * @ClassName: test07生产者消费者
 * @Author: 杨路恒
 * @Description:
 * @Date: 2021/8/27 0027 17:29
 * @Version: 1.0
 */
public class test07生产者消费者 {
    public static void main(String[] args) {
        Desk desk=new Desk();
        Foodie f=new Foodie(desk);
        Cooker c=new Cooker(desk);
        f.start();
        c.start();
    }
}

6.HashMap、HashTable、ConcurrentHashMap、CountDownLatch、

Semaphore

代码如下：

package com.xy;

import java.util.Hashtable;
import java.util.concurrent.ConcurrentHashMap;

/**
 * @ProjectName: day01
 * @Package: com.xy
 * @ClassName: test18并发工具类
 * @Author: 杨路恒
 * @Description:
 * @Date: 2021/8/29 0029 18:47
 * @Version: 1.0
 */
public class test20ConcurrentMap {
    public static void main(String[] args) throws InterruptedException {
        ConcurrentHashMap<String,String> map=new ConcurrentHashMap<>();
        Thread t1=new Thread(()->{
            for (int i = 0; i < 25; i++) {
                map.put(i+"",i+"");
            }
        });
        Thread t2=new Thread(()->{
            for (int i = 25; i < 51; i++) {
                map.put(i+"",i+"");
            }
        });
        t1.start();
        t2.start();
        Thread.sleep(1000);

        for (int i = 0; i < 51; i++) {
            System.out.println(map.get(i+""));
        }
    }
}




package com.xy;

import java.util.concurrent.CountDownLatch;

/**
 * @ProjectName: day01
 * @Package: com.xy
 * @ClassName: test21CountDownLatch
 * @Author: 杨路恒
 * @Description:
 * @Date: 2021/8/30 0030 20:49
 * @Version: 1.0
 */
public class test21CountDownLatch {
    public static void main(String[] args) {
        CountDownLatch countDownLatch=new CountDownLatch(3);
        MotherThread motherThread=new MotherThread(countDownLatch);
        motherThread.start();
        ChildThread1 t1=new ChildThread1(countDownLatch);
        t1.setName("杨大大");
        ChildThread2 t2=new ChildThread2(countDownLatch);
        t2.setName("恒大大");
        ChildThread3 t3=new ChildThread3(countDownLatch);
        t3.setName("路大大");
        t1.start();
        t2.start();
        t3.start();
    }
}


package com.xy;

import java.util.concurrent.Semaphore;

/**
 * @ProjectName: day01
 * @Package: com.xy
 * @ClassName: test22Semaphore
 * @Author: 杨路恒
 * @Description:
 * @Date: 2021/8/30 0030 21:07
 * @Version: 1.0
 */
public class test22Semaphore {
    public static void main(String[] args) {
        SemaphoreRunnable sr=new SemaphoreRunnable();
        for (int i = 0; i < 100; i++) {
            new Thread(sr).start();
        }
    }
}
class SemaphoreRunnable implements Runnable{
    private Semaphore semaphore=new Semaphore(2);
    @Override
    public void run() {
        try {
            semaphore.acquire();
            System.out.println("获得了通行证开始行驶");
            Thread.sleep(2000);
            System.out.println("归还通行证");
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

lhyangtop
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
面试：Java多线程基础知识
qq_36198826的博客
03-14 463
主要内容来自： Java-concurrency JavaGuide 一、线程状态及基本操作 1、创建线程的方式 继承Thread类，重写run()方法 实现Runable接口 实现Callable接口 实现 Runnable 接口和 Callable 接口的区别：Runnable 接口不会返回结果或抛出检查异常，但是Callable 接口可以。 2、线程状态转换 3、线程间的通信、协作 interrupted 中断可以理解为线程的一个标志位，它表示了一个运行中的线程是否被其他线程进行了中断操作。
Java面试之多线程篇
m0_67391870的博客
07-29 101
先自我介绍一下，小编13年上师交大毕业，曾经在小公司待过，去过华为OPPO等大厂，18年进入阿里，直到现在。深知大多数初中级java工程师，想要升技能，往往是需要自己摸索成长或是报班学习，但对于培训机构动则近万元的学费，着实压力不小。因此我收集了一份《java开发全套学习资料》送给大家，初衷也很简单，就是希望帮助到想自学又不知道该从何学起的朋友，同时减轻大家的负担。Java多线程-join和ThreadLocal的使用。Java多线程-手写一个死锁的例子。Java多线程-Lock锁的使用。...
Java——多线程
m0_48936146的博客
05-16 1126
1、继承Thread类创建多线程 1.1 在学习多线程之前，先来看看单线程程序。 class Mythread{ public void run(){ for(int i=1;i<100;i++){ System.out.println("MyThread类的run()方法在运行"); i+=1; } } } public class Example01 { public static voi
Java笔记-多线程相关
IT1995的博客
12-27 4904
ava多线程和C++里面的多线程有些地方不一样。 毕竟套了一个java虚拟机。对此记录下。 Java语言内置多线程支持： 一个java程序实际上是一个JVM进程。 JVM用一个主线程来执行main()方法。 在main()方法中又可以启动多个进程。 Java多线程创建MyThread类逻辑： 1.从Thread派生； 2.覆写run...
java thread和runnable_java中thread和runnable的区别
weixin_35666639的博客
02-19 949
展开全部线程的起动62616964757a686964616fe4b893e5b19e31333361326332并不是简单的调用了你的RUN方法,而是由一个线程调度器来分别调用你的所有线程的RUN方法,我们普通的RUN方法如果没有执行完是不会返回的,也就是会一直执行下去,这样RUN方法下面的方法就不可能会执行了,可是线程里的RUN方法却不一样,它只有一定的CPU时间,执行过后就给别的线程了,这样...
Thread 类及常用的方法
weixin_46103589的博客
04-10 3020
文章目录一、Thread 的常见构造方法二、Thread 的常见属性三、创建线程四、中断线程五、线程等待六、获取线程引用七、线程休眠八、线程状态 一、Thread 的常见构造方法 方法 说明 Thread() 创建线程对象 Thread(Runnable target) 使用 Runnable 对象创建线程对象 Thread(String name) 创建线程对象并命名 Thread(Runnable target,String name) 使用 Runnable 对象创建线程对
浅谈Java线程
最新发布
04-27 1352
100亿的值，如果在4核的CPU上利用4个线程执行，线程A计算[1，25亿)，线程B计算[25亿，50亿)，线程C计算[50，75亿)，线程D计算[75亿，100亿]，之后汇总，那么理论上应该比一个线程计算[1，100亿]快将近4倍，响应时间能够降到25%。其中的join()是一种线程同步方法，例如有一个线程对象thread A，当调用A.join()的时候，执行这条语句的线程会等待thread A执行完，而等待中的这个线程，其状态会从RUNNABLE转换到WAITING。因为利用多核可以降低响应时间。
java面试第二部分：多线程与锁
03-17
Java面试的第二部分聚焦于多线程和锁机制，这些是Java并发编程的关键知识点，对于理解和优化应用程序性能至关重要。以下是对这些概念的详细说明： **并行与并发** 并行是指多个处理器或多核处理器同时处理多个任务...
Java面试题-线程多线程.pdf
06-12
在Java编程中，线程多线程是...理解并掌握这些线程多线程的概念和用法，对于进行高效的并发编程至关重要，也是Java面试中不可或缺的部分。在实际项目中，合理地使用这些工具和技巧可以极大地提高程序的性能和稳定性。
多线程面试相关知识点
06-01
2. 什么是多线程： 多线程则指的是在单个程序中可以同时运行多个不同的线程执行不同的任务. 说明： 线程是程序内的顺序控制流，只能使用分配给程序的资源和环境。 多线程编程的目的，就是"最大限度地利用CPU资源...
MyThread --- a program about thread scheduling
11-16
It is a practice about thread scheduling. Threads can have 5 status: running, ready, block, wait, dead.
Java多线程-知识点梳理和总结-超详细-面试知识点.docx
12-17
"Java多线程-知识点梳理和总结-超详细-面试知识点" Java多线程是Java编程语言中最基本也是最重要的概念之一。多线程编程可以提高程序的执行效率、改善用户体验和提高系统的可扩展性。但是，多线程编程也存在一些...
Java面试知识点整理总结
04-07
Java面试知识点整理总结涵盖了多个关键领域，这对于求职者或希望提升技术能力的Java开发者来说是宝贵的资源。以下是对这些主题的详细阐述： 1. **Java基础**：这是学习任何编程语言的基础，包括变量、数据类型、...
QThread的用法
热门推荐
HuZhenXing
08-06 8万+
概述 QThread类提供了一个与平台无关的管理线程的方法。一个QThread对象管理一个线程。QThread的执行从run()函数的执行开始，在Qt自带的QThread类中，run()函数通过调用exec()函数来启动事件循环机制，并且在线程内部处理Qt的事件。在Qt中建立线程的主要目的就是为了用线程来处理那些耗时的后台操作，从而让主界面能及时响应用户的请求操作。下面就谈谈如何利用QT
myThread
北京的开始
04-15 992
// //  myThread.h //  myTask // //  Created by user on 12-4-9. //  Copyright (c) 2012年 __MyCompanyName__. All rights reserved. // #import @interface myThread : NSObject{     int a;
java 多线程
weixin_41992498的博客
06-17 115
多线程的实现方式：继承Thread类，实现Runable接口，实现Callable接口 Thread才是代表一个线程，Runnable只是定义了run方法
java多线程
梦想是很难很难的，所以先勇敢一点
03-08 667
我们说最常见的一种，就是我们A线程在进入方法后，拿到了count的值，刚把这个值读取出来还没有改变count的值的时候，结果线程B也进来的，那么导致线程A和线程B拿到的count值是一样的。为了保证每个线程都能正常执行原子操作,Java引入了线程同步机制。那么怎么去使用呢？同步代码块，synchronized 关键字可以用于方法中的某个区块中，表示只对这个区块的资源实行互斥访问。同步方法(底层锁是this)，在方法上，返回值前加synchronized锁机制。
线程（java学习4.1）
qq_43309933的博客
04-25 145
线程创建的两种方式 Thread类 构建方法 常用方法 自定义线程类： public class MyThread extends Thread{ public MyThread(String name) { super(name); } @Override public void run() { for (int i=0;...
数据库:MySQL和MariaDB的JDBC连接
岁月求索
05-26 2万+
目录 QUESTION:MySQL和MariaDB的JDBC连接？ ANSWER: 区别与联系： MySQL： MariaDB： java连接mariaDB数据库的设置：(tomcat 8) 第一种方法：使用tomcat自带的mysql-connector-java-5.1.40-bin.jar： 第二种，使用mariadb的jdbc Driver： QUESTION:My...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

lhyangtop

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值