java多线程面试题

最新推荐文章于 2021-03-18 00:14:19 发布
最新推荐文章于 2021-03-18 00:14:19 发布
阅读量506 收藏 1
点赞数
分类专栏： java 多线程 文章标签： 多线程 程序员 继承 类 java
转自：http://blog.csdn.net/caohaicheng/article/details/38071097

1、多线程有哪几种实现方法？举个例子说明下线程的同步。

（1）Java多线程有两种实现方式：继承Thread类和实现Runnable接口，Thread就是实现了Runnable接口。

两个最简单的线程例子：

[java] view plain copy print ? 在CODE上查看代码片 派生到我的代码片
  1. package chc.runnable;
  3. public class ThreadTest2 {
  4. public static void main(String[] args) throws InterruptedException {
  5. Thread1 t = new Thread1();
  6. //t.run(); //这里也不能直接调用方法
  7. t.start();
  8. for (int i = 0; i < 100; i++) {
  9. System.out.println("main:"+i);
  10. }
  11. }
  12. }
  14. class Thread1 extends Thread{
  15. public void run() {
  16. for (int i = 0; i < 100; i++) {
  17. System.out.println("Thread-----:"+i);
  18. }
  19. }
  20. } 
package chc.runnable;

public class ThreadTest2 {
    public static void main(String[] args) throws InterruptedException {
        Thread1 t = new Thread1();
        //t.run(); //这里也不能直接调用方法
        t.start();
        for (int i = 0; i < 100; i++) {
            System.out.println("main:"+i);
        }
    }
}

class Thread1 extends Thread{
    public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.println("Thread-----:"+i);
        }
    }
}
[java] view plain copy print ? 在CODE上查看代码片 派生到我的代码片
  1. package chc.runnable;
  3. public class ThreadTest1 {
  4. public static void main(String[] args) {
  5. Runnable1 r =new Runnable1();
  6. Thread t1=new Thread(r);
  7. t1.start();
  8. }
  9. }
  11. class Runnable1 implements Runnable {
  13. public void run() {
  14. // TODO Auto-generated method stub
  15. for (int i = 1; i <= 5; i++) {
  16. System.out.println("实现Runnable接口的线程----->"+i);
  17. }
  18. }
  20. } 
package chc.runnable;

public class ThreadTest1 {
	public static void main(String[] args) {
		Runnable1 r =new Runnable1();
		Thread t1=new Thread(r);
		t1.start();
	}
}

class Runnable1  implements Runnable {

	public void run() {
		// TODO Auto-generated method stub
		for (int i = 1; i <= 5; i++) {
			System.out.println("实现Runnable接口的线程----->"+i);
		}
	}

}

通过上两个例子发现，当启动线程的时候并不影响主程序的继续执行。

（2）线程同步问题

使用synchronnized关键字

银行账户存取钱的问题：

[java] view plain copy print ? 在CODE上查看代码片 派生到我的代码片
  1. public class ThreadTest {
  2. public static void main(String[] args){
  3. ThreadA t1=new ThreadA();
  4. t1.start();
  5. ThreadB t2=new ThreadB();
  6. t2.start();
  7. }
  8. }
  10. class ThreadA extends Thread{
  11. @Override
  12. public void run(){
  13. for(int i=0;i<100;i++){
  14. account.add();
  15. try {
  16. sleep(10);//模拟银行系统处理时间
  17. } catch (InterruptedException e) {
  18. // TODO Auto-generated catch block
  19. e.printStackTrace();
  20. }
  21. }
  22. }
  23. }
  25. class ThreadB extends Thread{
  26. @Override
  27. public void run() {
  28. for(int i=0;i<100;i++){
  29. account.remove();
  30. try {
  31. sleep(10);<span style="font-family: SimSun;">//模拟银行系统处理时间</span>
  32. } catch (InterruptedException e) {
  33. // TODO Auto-generated catch block
  34. e.printStackTrace();
  35. }
  36. }
  37. }
  38. }
  40. class account {
  41. public static int count=1000;
  43. //减去100元
  44. public static synchronized void remove(){
  45. count=count-100;
  46. System.out.println("减去100元,卡内余额"+count);
  47. }
  49. //增加100元
  50. public static synchronized void add(){
  51. count=count+100;
  52. System.out.println("加上100元,卡内余额"+count);
  53. }
  54. } 
public class ThreadTest {
	public static void main(String[] args){
		ThreadA  t1=new ThreadA();
		t1.start();
		ThreadB  t2=new ThreadB();
		t2.start();
	}
}

class ThreadA extends Thread{
	@Override
	public void run(){
		for(int i=0;i<100;i++){
			account.add();
			try {
				sleep(10);//模拟银行系统处理时间
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}
	}
}

class ThreadB extends Thread{
	@Override
	public void run() {
		for(int i=0;i<100;i++){
			account.remove();
			try {
				sleep(10);<span style="font-family: SimSun;">//模拟银行系统处理时间</span>
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}
	}
}

class account {
	public static   int count=1000;
	
	//减去100元
	public static synchronized void remove(){
		count=count-100;
		System.out.println("减去100元,卡内余额"+count);
	}
	
	//增加100元
	public static synchronized void add(){
		count=count+100;
		System.out.println("加上100元,卡内余额"+count);
	}
}
注意：上例中将account类的add()和remove()方法都加上了static关键字，因为这样在线程中可以直接通过类名调用到这两个方法，而不需要实例化对象。

因为synchronized同步只对同一个对象中的方法有效，也就是说一个线程正在执行account的add()方法，另一个线程是可以调用到另一个对象的add方法的。

2、启动一个线程是用run()还是start()，调用的时候有什么区别？

当然是start()了，当调用线程的start()方法的时候，线程就会进入到就绪状态

run()方法是线程的执行入口，当线程从就绪状态进入到执行状态时首先要从run()方法开始执行。

当然，我们也是可以直接通过线程对象调用该对象的run()方法的，只是这只是一次普通的调用，并没有启动任何一个线程。

当我们调用start()方法时，是另外启动了一个线程去执行线程类的代码，并不影响主程序的执行，但是调用run()方法的时候要等待run()方法内的代码执

行完主程序才可以向下执行，举个例子:

[java] view plain copy print ? 在CODE上查看代码片 派生到我的代码片
  1. public class ThreadDemo2 {
  2. public static void main(String[] args) {
  3. Thread5 t1=new Thread5();
  4. Thread6 t2=new Thread6();
  5. t1.run();
  6. t2.start();
  7. for(int i=0;i<100;i++){
  8. System.out.println("主进程执行："+i);
  9. }
  10. }
  11. }
  13. class Thread5 extends Thread{
  14. @Override
  15. public void run() {
  16. for(int i=0;i<100;i++){
  17. System.out.println("Thread5执行："+i);
  18. }
  19. }
  20. }
  22. class Thread6 extends Thread{
  23. @Override
  24. public void run() {
  25. for(int i=0;i<100;i++){
  26. System.out.println("Thread6执行："+i);
  27. }
  28. }
  29. } 
public class ThreadDemo2 {
	public static void main(String[] args) {
		Thread5 t1=new Thread5();
		Thread6 t2=new Thread6();
		t1.run();
		t2.start();
		for(int i=0;i<100;i++){
			System.out.println("主进程执行："+i);
		}
	}
}

class Thread5 extends Thread{
	@Override
	public void run() {
		for(int i=0;i<100;i++){
			System.out.println("Thread5执行："+i);
		}
	}
}

class Thread6 extends Thread{
	@Override
	public void run() {
		for(int i=0;i<100;i++){
			System.out.println("Thread6执行："+i);
		}
	}
}
输出结果的顺序是：Thread5全部打印完后 Thread6和主程序交替打印。验证了上面的说法

3、当一个线程进入到一个对象的synchronized方法，那么其他线程是否可以进入该对象的其它方法？

不一定，看情况

如果其它方法加了static关键字，那么该方法属于类，不属于对象，不能与对象的方法保持同步（即使有synchronized关键字），是能进入的。

如果其它方法不带有static关键字且带有synchronized关键字，那么不能进入，如果不带，则能。

再其次就看方法内部有没有wait（）方法释放锁了

4、子线程循环2次，接着主线程循环3次，接着子线程循环3次，接着主线程循环3次，如此循环5次，请写出程序代码。

[java] view plain copy print ? 在CODE上查看代码片 派生到我的代码片
  1. public class ThreadDemo5 {
  2. static boolean thread_flag=false;//指示子线程循环是否结束
  3. static boolean main_flag=true; //调用子线程的start方法后变为true,循环等待thread_flag为true（也就是子线程循环完）的时刻，主线程循环完又变为false;
  4. public static void main(String[] args) {
  5. for(int k=0;k<5;k++){
  6. Thread7 t=new Thread7();
  7. t.start();
  8. main_flag=true;
  9. while (main_flag) {//循环等待thread_f
  10. if(thread_flag){
  11. for(int i=0;i<3;i++){
  12. System.out.println("主线程第一次循环"+(i+1)+"次");
  13. }
  14. thread_flag=false;
  15. main_flag=false;
  16. }
  17. }
  18. }
  19. }
  20. }
  22. class Thread7 extends Thread {
  23. static boolean flag=true;//标志子线程第几次循环，当值为true的时候子线程循环2次，否则循环3次
  24. public void run() {
  25. if(flag){
  26. for(int i=0;i<2;i++){
  27. System.out.println("子线程第一次循环"+(i+1)+"次");
  28. }
  29. flag=false;
  30. }else{
  31. for(int i=0;i<3;i++){
  32. System.out.println("子线程第二次循环"+(i+1)+"次");
  33. }
  34. flag=true;
  35. }
  36. ThreadDemo5.thread_flag=true;
  39. }
  40. } 
public class ThreadDemo5 {
	static boolean thread_flag=false;//指示子线程循环是否结束
	static boolean main_flag=true;   //调用子线程的start方法后变为true,循环等待thread_flag为true（也就是子线程循环完）的时刻，主线程循环完又变为false;
	public static void main(String[] args) {
		for(int k=0;k<5;k++){
			Thread7 t=new Thread7();
			t.start();
			main_flag=true;
			while (main_flag) {//循环等待thread_f
				if(thread_flag){
					for(int i=0;i<3;i++){
						System.out.println("主线程第一次循环"+(i+1)+"次");
					}
					thread_flag=false;
					main_flag=false;
				}	
			}
		}
	}
}

class Thread7 extends Thread {
	static boolean flag=true;//标志子线程第几次循环，当值为true的时候子线程循环2次，否则循环3次
	public void run() {
		if(flag){
			for(int i=0;i<2;i++){
				System.out.println("子线程第一次循环"+(i+1)+"次");
			}
			flag=false;
		}else{
			for(int i=0;i<3;i++){
				System.out.println("子线程第二次循环"+(i+1)+"次");
			}
			flag=true;
		}
		ThreadDemo5.thread_flag=true;
		
		
	}
}

这个题就是要注意调用子线程的start方法的时候并不能阻止主程序继续向下执行，所以我们要用变量来标记。

5、sleep()和wait()有何异同？

（1）首先一个最明显的区别是 wait是Object类的方法,而sleep()是Thread类的静态方法,谁调用了该方法谁去休眠,即使在a线程里调用了b线程的sleep方法,实际上还是a线程去休眠.

（2）比较重要的一点是sleep没有释放出锁，而wait释放了锁，是其他线程可以使用同步块资源。

sleep不出让系统资源；wait是进入线程等待池等待，出让系统资源，其他线程可以占用CPU。一般wait不会加时间限制，因为如果wait线程的运行资源不够，再出来也没用，要

等待其他线程调用notify/notifyAll唤醒等待池中的所有线程，才会进入就绪队列等待OS分配系统资源。sleep(milliseconds)可以用时间指定使它自动唤醒过来，如果时间不到

只能调用interrupt()强行打断。

（3）使用范围：

wait，notify和notifyAll只能在同步控制方法或者同步控制块里面使用，而sleep可以在任何地方使用
synchronized(x){
x.notify()
//或者wait()
}

（4）sleep需要捕获异常,而wait不需要。

6、现在有T1 T2 T3三个线程，怎样保证T2在T1执行完之后执行 T3在T2执行完之后执行

这题主要是考察对join()方法的使用。

当线程A当中执行了线程B.join()，那么A线程要等待B线程执行完才可以执行。

[java] view plain copy print ? 在CODE上查看代码片 派生到我的代码片
  1. public class JoinDemo {
  2. public static void main(String[] args) {
  3. T1 t1=new T1("T1");
  4. T2 t2=new T2("T2");
  5. T3 t3=new T3("T3");
  6. t1.start();
  7. try {
  8. t1.join();
  9. } catch (InterruptedException e) {
  10. // TODO Auto-generated catch block
  11. e.printStackTrace();
  12. }
  13. t2.start();
  14. try {
  15. t2.join();
  16. } catch (InterruptedException e) {
  17. // TODO Auto-generated catch block
  18. e.printStackTrace();
  19. }
  20. t3.start();
  21. }
  22. }
  24. class T1 extends Thread{
  25. private String name;
  26. public T1(String name) {
  27. this.name=name;
  28. }
  30. @Override
  31. public void run() {
  32. for(int i=0;i<5;i++){
  33. try {
  34. sleep(5);
  35. } catch (InterruptedException e) {
  36. // TODO Auto-generated catch block
  37. e.printStackTrace();
  38. }
  39. System.out.println(this.name+"循环"+i);
  40. }
  41. }
  42. }
  43. class T2 extends Thread{
  44. private String name;
  45. public T2(String name) {
  46. this.name=name;
  47. }
  48. @Override
  49. public void run() {
  50. for(int i=0;i<5;i++){
  51. try {
  52. sleep(5);
  53. } catch (InterruptedException e) {
  54. // TODO Auto-generated catch block
  55. e.printStackTrace();
  56. }
  57. System.out.println(this.name+"循环"+i);
  58. }
  59. }
  60. }
  61. class T3 extends Thread{
  62. private String name;
  63. public T3(String name) {
  64. this.name=name;
  65. }
  66. @Override
  67. public void run() {
  68. for(int i=0;i<5;i++){
  69. System.out.println(this.name+"循环"+i);
  70. }
  71. }
  72. } 
public class JoinDemo {
	public static void main(String[] args) {
		T1 t1=new T1("T1");
		T2 t2=new T2("T2");
		T3 t3=new T3("T3");
		t1.start();
		try {
			t1.join();
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		t2.start();
		try {
			t2.join();
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		t3.start();
	}
}

class T1 extends  Thread{
	private String name;
	public T1(String name) {
		this.name=name;
	}

	@Override
	public void run() {
		for(int i=0;i<5;i++){
			try {
				sleep(5);
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
			System.out.println(this.name+"循环"+i);
		}
	}
}
class T2 extends  Thread{
	private String name;
	public T2(String name) {
		this.name=name;
	}
	@Override
	public void run() {
		for(int i=0;i<5;i++){
			try {
				sleep(5);
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
			System.out.println(this.name+"循环"+i);
		}
	}
}
class T3 extends  Thread{
	private String name;
	public T3(String name) {
		this.name=name;
	}
	@Override
	public void run() {
		for(int i=0;i<5;i++){
			System.out.println(this.name+"循环"+i);
		}
	}
}

7、简述synchronized和java.util.concurrent.locks.Lock的异同？

主要相同点：Lock能完成synchronized所实现的所有功能

主要不同点：Lock有比synchronized更精确的线程语义和更好的性能。synchronized会自动释放锁，而Lock一定要求程序员手工释放，并且必须在finally从句中释放。

Lock还有更强大的功能，例如，它的tryLock方法可以非阻塞方式去拿锁。

8、死锁问题

后续补充……

武大西门
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java多线程面试题归纳
曹海成的专栏
07-24 1万+
1、线程的基本概念、线程的基本状态以及状态之间的关系
Java多线程面试题
D.K专栏
07-07 1183
1)现在有T1、T2、T3三个线程，你怎样保证T2在T1执行完后执行，T3在T2执行完后执行？  这个线程问题通常会在第一轮或电话面试阶段被问到，目的是检测你对”join”方法是否熟悉。这个多线程问题比较简单，可以用join方法实现。 Java多线程中join方法的理解 2)在Java中Lock接口比synchronized块的优势是什么？你需要实现一个高效的缓存，它允许多个用户
java多线程面试题59题集合
最新发布
03-15
以下是对Java多线程面试题59题集合中可能涉及的一些关键知识点的详细解析。 1. **线程的创建方式** - 继承Thread类：创建一个新的类，该类继承自Thread类，并重写其run()方法。 - 实现Runnable接口：创建一个实现...
java多线程面试题和答案
02-22
以下是一些关于Java多线程的面试题及其答案，涵盖了基础概念、并发控制、线程安全以及性能优化等方面。 1. **什么是Java多线程？** 多线程是指在单个程序中同时执行多个线程，这样可以提高应用程序的效率和响应...
15个顶级Java多线程面试题（附答案）
08-31
Java多线程是Java编程中不可或缺的部分，尤其在面试中，这一领域的知识是评估程序员能力的重要标准。以下是一些关于Java多线程的面试重点： 1. **线程的顺序控制**：面试题中提到的T1、T2、T3线程顺序执行问题，...
15个高级Java多线程面试题及回答
09-04
以下是一些高级Java多线程面试题及其涉及的知识点： 1. **如何保证线程执行顺序？** - 使用`Thread.join()`方法可以使一个线程等待另一个线程完成后再继续执行，以此来控制线程的执行顺序。 2. **Lock接口相比于`...
JAVA - 多线程 - 面试题
weixin_43125677的博客
08-19 290
JAVA - 线程 - 面试题
Java多线程 面试题
qq_42691486的博客
08-16 298
synchronized是通过对象的监视器完成线程同步（线程互斥）的，每个对象的对象头中都有一个监视器（修饰静态代码块时，锁对象是类，类在jvm中有自己的Class对象），每一个线程进入同步代码块之前都会尝试获取锁对象的监视器，如果获取成功，则可以进入执行，否则就会被阻塞，直到获取锁的线程释放锁，才可以去竞争锁，竞争成功才可以进入同步代码块或同步方法。锁升级是为了减低了锁带来的性能消耗。何谓公平性，是针对获取锁而言的，如果一个锁是公平的，那么锁的获取顺序就应该符合请求上的绝对时间顺序，满足FIFO。
Java 多线程面试题
filling_l的博客
03-18 133
文章目录1 什么是进程？什么是线程？进程和线程的区别（从java语言的角度来讲解）？2 说数并发和并行的区别？3 为什么要使用多线程呢？4 使用多线程能带来什么问题？临界资源？5 说说线程的生命周期？6 线程状态阻塞和等待状态的区别？7 JMM的作用是什么？8 as-if -serial是什么？9 heppens-before是什么？10 什么是指令重排序？11 as-if-serial 和happens-before有什么区别？12 程序计数器为什么是线程私有的？13 虚拟机栈为什么是线程私有的？14 用
面试题集锦-多线程
yyqhwr的博客
11-14 295
多线程1. 并行和并发有什么区别？2. 线程和进程的区别？3. 守护线程是什么？4. 创建线程有哪几种方式？5. 说一下 runnable 和 callable 有什么区别？6. 线程有哪些状态？7. sleep() 和 wait() 有什么区别？8. notify()和 notifyAll()有什么区别？9. 线程的 run() 和 start() 有什么区别？10. 创建线程池有哪几种方式？11. 线程池都有哪些状态？12. 线程池中 submit() 和 execute() 方法有什么区别？13. 在
Java面试题之多线程
while false
03-18 1423
1.进程间的通信方式 无名管道通信：管道是一种半双工的通信方式，数据只能单向流动，而且只能在具有亲缘关系的进程间使用，进程间的亲缘关系通常是指父子进程 高级管道通信：将另一个程序当作一个新的进程在当前程序进程中启动，那么它算是当前进程的子进程，这种方式我们称为高级管道方式 有名管道通信：有名管道通信也是半双工的通信方式，但是它允许在无亲缘关系的进程间使用 消息队列通信：消息队列是消息的链表...
Java面试题--多线程
热门推荐
青春季风暴
04-07 1万+
什么是线程？ 线程是操作系统能够进行运算调度的最小单位，它被包含在进程之中，是进程中的实际运作单位。程序员可以通过它进行多处理器编程，你可以使用多线程对运算密集型任务提速。 线程和进程有什么区别？ 线程是进程的子集，一个进程可以有很多线程，每条线程并行执行不同的任务。不同的进程使用不同的内存空间，而所有的线程共享一片相同的内存空间。 如何在Java中实现线程？ 由于线程类本身就是调用的...
Java多线程面试题答案解析与Lock接口优势
本文主要探讨了Java多线程面试中常见的15个问题及其答案。首先，对于如何确保线程T2在T1执行完后再执行，然后T3在T2之后执行的问题，答案是使用`join()`方法。`join()`方法的作用是使得调用它的线程等待被调用的线程...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值