java 多线程面试（面试问 关于JAVA多线程,从哪些方面回答呢）

本文目录

• 面试问 关于JAVA多线程,从哪些方面回答呢
• java 线程面试题
• java面试中经常被问到的问题有哪些
• java多线程runnable和thread的区别 面试题
• 面试的时候都会问到多线程的问题，但实际很多项目并不会涉及到，那么java中什么类型的数据需要多线程处理
• java面试什么是多线程
• java面试 谈谈多线程 ,怎么回答

面试问 关于JAVA多线程,从哪些方面回答呢

1. 应用场景

   即作用是什么，哪些场景下需要，能解决哪类问题，通常情况下面试官更关心这个。

2. 实现方式

   除了什么时候用，你还得告诉他怎么用。什么Thread、Runnable、线程池之类的丢上去，这些比较基础。

3. 线程同步

   这个问题其实比较复杂。线程同步的概念最易于理解的案例就是在生产者消费者模式中的应用，你可以跟他讲讲这个。当然，这个涉及到对象锁基本就够了。

   然后你再说说线程同步的几个方式，synchronized（对象、方法）、Lock、wait/notify之类的，说说它们的区别和应用场景。

   最后提一提JDK中那些容器的线程同步问题，这样基本的使用算是不会有大问题了。

上面的东西你都能讲清楚，你多线程上的内容也就回个7788了，这块儿的面试基本没问题了

java 线程面试题

我不知道你是不是这个意思，thread1，thread2两个线程每次让j增加1，thread3，thread4两个线程每次让j减少1，四个线程每个都调用250次相关加减一操作。最终j的结果都是100.下面程序，总计会打印出1000个数，不管怎么样最后一个数永远是100，即j的终值永远是100，为了看中间结果运行过程我加了sleep，但无关紧要。你看看符合你要求不？就像楼上说的，启动1000条线程不是很明白，不一致的继续讨论package com.kalort;public class ThreadTest{ public static void main(String args) { Operator operator = new Operator(); Thread thread1 = new IncreaseThread(operator); Thread thread2 = new IncreaseThread(operator); Thread thread3 = new DecreaseThread(operator); Thread thread4 = new DecreaseThread(operator); thread1.start(); thread2.start(); thread3.start(); thread4.start(); }}class IncreaseThread extends Thread{ private Operator operator; public IncreaseThread(Operator operator) { this.operator = operator; } public void run() { for (int i = 0; i 《 250; i++) { try { Thread.sleep((long)(Math.random() * 100)); } catch (InterruptedException e) { e.printStackTrace(); } operator.increase(); } }}class DecreaseThread extends Thread{ private Operator operator; public DecreaseThread(Operator operator) { this.operator = operator; } public void run() { for (int i = 0; i 《 250; i++) { try { Thread.sleep((long)(Math.random() * 100)); } catch (InterruptedException e) { e.printStackTrace(); } operator.decrease(); } }}class Operator{ private int j = 100; public synchronized void increase() { while (100 != j) { try { wait(); // 如果另外线程还没减一就等待 } catch (InterruptedException e) { e.printStackTrace(); } } j++; System.out.println(j); notify(); // 通知另外线程已经加一了。 } public synchronized void decrease() { while (100 == j) { try { wait(); } catch (InterruptedException e) { // TODO Auto-generated catch block e.printStackTrace(); } } j--; System.out.println(j); notify(); }}

java面试中经常被问到的问题有哪些

java面试中经常被问到的问题有如下：

1、进程，线程，协程之间的区别是什么？

简而言之，进程是程序运行和资源分配的基本单位，一个程序至少有一个进程，一个进程至少有一个线程。进程在执行过程中拥有独立的内存单元，而多个线程共享内存资源，减少切换次数，从而效率更高。线程是进程的一个实体，是cpu调度和分派的基本单位，是比程序更小的能独立运行的基本单位。同一进程中的多个线程之间可以并发执行。

2、你了解守护线程吗？它和非守护线程有什么区别？

程序运行完毕，jvm会等待非守护线程完成后关闭，但是jvm不会等待守护线程。守护线程最典型的例子就是GC线程。

3、什么是多线程上下文切换？

多线程的上下文切换是指CPU控制权由一个已经正在运行的线程切换到另外一个就绪并等待获取CPU执行权的线程的过程。

4、创建两种线程的方式?他们有什么区别？

通过实现java.lang.Runnable或者通过扩展java.lang.Thread类。相比扩展Thread，实现Runnable接口可能更优.原因有二：Java不支持多继承。因此扩展Thread类就代表这个子类不能扩展其他类。而实现Runnable接口的类还可能扩展另一个类。类可能只要求可执行即可，因此继承整个Thread类的开销过大。

5、Thread类中的start()和run()方法有什么区别?

start()方法被用来启动新创建的线程，而且start()内部调用了run()方法，这和直接调用run()方法的效果不一样。当你调用run()方法的时候，只会是在原来的线程中调用，没有新的线程启动，start()方法才会启动新线程。

java多线程runnable和thread的区别 面试题

runnable和thread的区别（多线程必须用Runable）Java中有两种实现多线程的方式以及两种方式之间的区别看到一个面试题.问两种实现多线程的方法.没事去网上找了找答案. 网上流传很广的是一个网上售票系统讲解.转发过来.已经不知道原文到底是出自哪里了. Java中有两种实现多线程的方式。一是直接继承Thread类，二是实现Runnable接口。那么这两种实现多线程的方式在应用上有什么区别呢？ 为了回答这个问题，我们可以通过编写一段代码来进行分析。我们用代码来模拟铁路售票系统，实现通过四个售票点发售某日某次列车的100张车票，一个售票点用一个线程表示。 首先这样编写这个程序： Java代码 class ThreadTest extends Thread{private int ticket = 100;public void run(){while(true){if(ticket 》 0){System.out.println(Thread.currentThread().getName() +“is saling ticket“ + ticket--);}else{break;}}} } 源码打印？class ThreadTest extends Thread{private int ticket = 100;public void run(){while(true){if(ticket 》 0){System.out.println(Thread.currentThread().getName() +“is saling ticket“ + ticket--);}else{break;}}} } main测试类: Java代码 public class ThreadDome1{public static void main(String args){ThreadTest t = new ThreadTest();t.start();t.start();t.start();t.start();} } 源码打印？public class ThreadDome1{public static void main(String args){ThreadTest t = new ThreadTest();t.start();t.start();t.start();t.start();} } 上面的代码中，我们用ThreadTest类模拟售票处的售票过程，run方法中的每一次循环都将总票数减1，模拟卖出一张车票，同时该车票号打印出来，直接剩余的票数到零为止。在ThreadDemo1类的main方法中，我们创建了一个线程对象，并重复启动四次，希望通过这种方式产生四个线程。从运行的结果来看我们发现其实只有一个线程在运行，这个结果 告诉我们：一个线程对象只能启动一个线程，无论你调用多少遍start()方法，结果只有一个线程。 我们接着修改ThreadDemo1，在main方法中创建四个Thread对象： Java代码 public class ThreadDemo1{public static void main(String args){new ThreadTest().start();new ThreadTest().start();new ThreadTest().start();new ThreadTest().start();} } 源码打印？public class ThreadDemo1{public static void main(String args){new ThreadTest().start();new ThreadTest().start();new ThreadTest().start();new ThreadTest().start();} } Java代码 class ThreadTest extends Thread{private int ticket = 100;public void run(){while(true){if(ticket 》 0){System.out.println(Thread.currentThread().getName() +“ is saling ticket“ + ticket--);}else{break;}}} } 源码打印？class ThreadTest extends Thread{private int ticket = 100;public void run(){while(true){if(ticket 》 0){System.out.println(Thread.currentThread().getName() +“ is saling ticket“ + ticket--);}else{break;}}} } 这下达到目的了吗？ 从结果上看每个票号都被打印了四次，即 四个线程各自卖各自的100张票，而不去卖共同的100张票。这种情况是怎么造成的呢？我们需要的是，多个线程去处理同一个资源，一个资源只能对应一个对象，在上面的程序中，我们创建了四个ThreadTest对象，就等于创建了四个资源，每个资源都有100张票，每个线程都在独自处理各自的资源。 经过这些实验和分析，可以总结出，要实现这个铁路售票程序，我们只能创建一个资源对象，但要创建多个线程去处理同一个资源对象，并且每个线程上所运行的是相同的程序代码。在回顾一下使用接口编写多线程的过程。 Java代码 public class ThreadDemo1{public static void main(String args){ThreadTest t = new ThreadTest();new Thread(t).start();new Thread(t).start();new Thread(t).start();new Thread(t).start();} } 源码打印？public class ThreadDemo1{public static void main(String args){ThreadTest t = new ThreadTest();new Thread(t).start();new Thread(t).start();new Thread(t).start();new Thread(t).start();} } Java代码 class ThreadTest implements Runnable{private int tickets = 100;public void run(){while(true){if(tickets 》 0){System.out.println(Thread.currentThread().getName() +“ is saling ticket “ + tickets--);}}} } 源码打印？class ThreadTest implements Runnable{private int tickets = 100;public void run(){while(true){if(tickets 》 0){System.out.println(Thread.currentThread().getName() +“ is saling ticket “ + tickets--);}}} } 上面的程序中，创建了四个线程， 每个线程调用的是同一个ThreadTest对象中的run()方法，访问的是同一个对象中的变量（tickets）的实例，这个程序满足了我们的需求。在Windows上可以启动多个记事本程序一样，也就是多个进程使用同一个记事本程序代码。 可见， 实现Runnable接口相对于继承Thread类来说，有如下显著的好处： (1)适合多个相同程序代码的线程去处理同一资源的情况，把虚拟CPU（线程）同程序的代码，数据有效的分离，较好地体现了面向对象的设计思想。 (2)可以避免由于Java的单继承特性带来的局限。我们经常碰到这样一种情况，即当我们要将已经继承了某一个类的子类放入多线程中，由于一个类不能同时有两个父类，所以不能用继承Thread类的方式，那么，这个类就只能采用实现Runnable接口的方式了。 (3)有利于程序的健壮性，代码能够被多个线程共享，代码与数据是独立的。当多个线程的执行代码来自同一个类的实例时，即称它们共享相同的代码。多个线程操作相同的数据，与它们的代码无关。当共享访问相同的对象是，即它们共享相同的数据。当线程被构造时，需要的代码和数据通过一个对象作为构造函数实参传递进去，这个对象就是一个实现了Runnable接口的类的实例。

面试的时候都会问到多线程的问题，但实际很多项目并不会涉及到，那么java中什么类型的数据需要多线程处理

多个线程都会操作的数据，也叫临界区数据。就像几个厨子共用一把刀和菜板，为避免一人拿刀，一人拿菜板，分配一定要同时分配给一个人。其实就是这个意思，多线程编程需要处理的就是这样，多个数据有逻辑完整性的情况。需要锁定资源，进行多线程互斥操作。说起来很玄妙，其实就是和分刀和菜板一个道理。

java面试什么是多线程

线程定义比较抽象，简单的说就是一个代码执行流。许多执行流可以混合在一起由CPU调度。线程是允许各种任务交互执行的方式。Java的线程在操作系统的实现模式依系统不同而不同，可能是系统级别的进程或线程，但对于程序员来说并没有影响。任务交互的一个好处是增加程序响应。如一个界面程序执行一段耗时的数据库查询，使用单独的线程可以让界面依然响应用户的其他输入，而单线程只能等待查询结束再处理。JVM以及操作系统会优先处理优先级别高的线程，但不代表这些线程一定会先完成。设定优先级只能建议系统更快的处理，而不能强制。另外，在运行时，并没有按照函数分界，而是按照机器码/汇编码分界。也就是说不保证任何一段代码是被完整而不打断的执行的（除非你已经使用同步手段）。正由于如此，各种线程同步的方法应运而生。

java面试 谈谈多线程 ,怎么回答

就谈谈你理解的多线程是什么样子的，说说多线程的一般使用情况、适用情况和基本的一些函数，怎么实现多线程，多线程和单线程的区别，就OK了，他要再深问再深入说咯。。。。