关于 Java 中多线程的面试问题详解

多线程细节:

1. 面试题: sleep 方法和 wait 方法异同点是什么?

相同点: 可以让线程处于冻结状态.

不同点:

1.
sleep 必须指定时间
wait 可以指定时间, 也可以不指定时间.

2.

sleep 时间到线程会处于临时阻塞或者运行.

wait 如果没有指定时间 , 必须要通过 notify 或者 notifyAll 唤醒.

3.

sleep 不一定非要定义在同步中.

wait 必须要定义在同步中. (锁)

4.

都定义在同步中,

线程执行到 sleep, 不会释放锁. (因为 sleep 肯定能醒)

线程执行到 wait, 会释放锁. (wait 就不一定能醒)

5.

方法名不相同

// *** 此时的同步代码块中有多个线程, 不会出现线程安全问题.

// *** 因为里面的线程光有执行权是不够的, 还得需要锁.

synchronized(obj)
{
// sleep(5000); // *** 5000 毫秒, 也就是 5 秒. // *** 释放执行权,

wait(); // *** 0 1 2 // *** 线程池. 这三个线程一旦被唤醒, 都会处于临时阻塞状态.

code...

}

synchronized(obj){

notifyAll(); // *** 3 // *** 持有锁.

code...

// *** 释放锁对于同步代码块而言是隐式的, 会在同步代码块的最后释放锁.
}

2. 线程如何停止呢?

扫描二维码关注公众号，回复： 7764965 查看本文章

stop 方法过时了, 看其描述发现, 有其它解决方案.

线程结束: 就是让线程任务代码执行完, run 方法结束.

run 方法咋结束呢?

run 方法中通常都定义循环, (如果没有定义循环就不要开启多线程了, 没有意义.), 只要控制循环就哦了.

*** 注意: 万一线程在任务中处于了冻结状态, 那么它还能去判断标记吗? 不能!

咋办? 答: *** 通过查阅 stop 方法的描述, 发现提供了一个解决方法, 如果目标线程等待很长时间, 则应使用 interrupt 方法来中断等待.

所谓的中断并不是停止线程.

*** interrupt 功能是将线程的冻结状态清除, 让线程恢复到运行状态(让线程重新具备 CPU 的执行资格).

*** interrupt 让线程从冻结状态恢复回来. 清除其中断状态.

*** 因为是强制性的, 所以会有异常发生, 可以在 catch 中捕获异常, *** 在异常处理中, 改变标记让循环结束, 让 run 方法结束.

3. 守护线程：后台线程，一般创建的都是前台线程。

前台后台线程运行时都是一样的，获取 CPU 的执行权执行。

只有结束的时候有些不同。

前台线程要通过 run 方法结束，线程结束。

后台线程也可以通过 run 方法结束，线程结束，还有另一种情况，

当进程中所有的前台线程都结束了，这时无论后台线程处于什么样的状态，都会结束，从而进程结束。

进程结束依赖的都是前台线程。

之所以这里称之为守护线程，无非是后台线程在守护着前台线程。

前台线程们结束了，后台线程就自动跟着结束了。

4. 线程的优先级：是用数字标识的： 1-10

其中默认初始优先级是 5。最明显的三个优先级 1， 5， 10

setPriority(10); // *** 设置线程的优先级。

setPriority(Thread.MAX_PRIORITY);

setPriority(Thread.MIN_PRIORITY);

setPriority(Thread.NORM_PRIORITY);

5. 线程组： ThreadGroup: 可以通过 Thread 的构造函数明确新线程对象所属的线程组。

线程组的好处：可以对多个同组的线程，进行统一的操作。

默认都属于 main　线程组。

6. 线程是可以自己取名字的。

例如：

Thread t1 = new Thread(d,"旺财"); // *** 旺财线程名

Thread t2 = new Thread(d,"小强"); // *** 小强线程名

可以自己给线程取名以增强程序的阅读性。

例如：

输入线程，运行线程 etc.

7. join 方法

主线程执行到这里，知道 t1 要加入执行，主线程释放了执行权、执行资格并处于冻结状态，什么时候恢复呢？

等 t1 线程执行完。
try{t1.join();}catch(InterruptedException e){}

try{t1.join();}catch(InterruptedException e){} // *** 一般这个方法用于临时加入一个运算的线程，让该线程运算完，程序才会继续执行。

8. yield（）； (static 静态的)

// *** 暂停当前正在执行的线程对象，并执行其它线程。

Thread.yield(); // *** 线程临时暂停。将执行权释放，让其他线程有机会获取执行权。

// *** 嵌套类也就是内部类。

9. 开发中，线程匿名内部类体现。

// *** 面试题

new Thread(new Runnable() // *** 就是往里面传递了一个线程任务对象。在执行的时候，就按照这个对象的任务来执行。
{
public void run(){
}

}).start();

// *** 面试题

new Thread(new Runnable() // *** 就是往里面传递了一个线程任务对象。在执行的时候，就按照这个对象的任务来执行。
{
public void run(){

System.out.println("runnable run");
}

}){

public void run(){

System.out.println("subthread run");
}

}.start();

}

  1 public class ThreadTest{
  2     
  3     public static void main(String[] args) {
  4         
  5     /*
  6     // *** 使用 匿名内部类的方式 创建一个 线程。    
  7         new Thread(){ // *** 这是一个 Thread 的子类对象， 可以 进行 覆盖 run 方法的操作。
  8             
  9             public void run(){
 10                 
 11                 for(int x = 0; x < 40; x++){
 12                     System.out.println(Thread.currentThread().getName() +"....X...." + x);
 13                 }
 14         }
 15         
 16 }.start();
 17         
 18         
 19     Runnable r = new Runnable(){
 20         
 21         public void run(){
 22             
 23             for(int x = 0; x < 40; x++){
 24                 System.out.println(Thread.currentThread().getName() +"....Y...." + x);
 25             }
 26             
 27         }
 28         
 29     };
 30     
 31     new Thread(r).start();
 32 
 33 
 34         
 35         for(int x = 0; x < 40; x++){
 36             System.out.println(Thread.currentThread().getName() +"....Z...." + x);
 37         }
 38         
 39         */
 40         
 41         // *** 面试题
 42         
 43         new Thread(new Runnable() // *** 就是 往里面 传递了 一个 线程任务对象。 在 执行的时候， 就按照 这个对象的 任务来执行。
 44         {
 45             public void run(){    
 46                 
 47                 System.out.println("runnable run");
 48             }
 49             
 50             
 51         }){
 52             
 53             public void run(){
 54                 
 55                 
 56                 System.out.println("subthread run");   // *** 执行
 57             }
 58             
 59         }.start();  // new  Thread 后面是一个 大括号, 就是一个 子类.
 60         
 61     }
 62 //***  子类 覆盖 父类,  运行的 时候 运行的 是 子类 方法.
 63 
 64 }
 65 
 66 
 67 
 68 /*
 69 
 70 class Thread{
 71     
 72     private Runnable r;
 73     Thread(Runnable r)
 74     {
 75         
 76         this.r = r;
 77         
 78     }
 79     
 80     public void run(){
 81         
 82         
 83         if(r != null){
 84             
 85             
 86             r.run(); // *** 这里调用的 是 Runnable 的 run 方法.
 87             
 88         }
 89         
 90     }
 91     
 92     public void start(){
 93         
 94         run();
 95         
 96         
 97     }
 98     
 99 }
100 
101 class SubThread  extends Thread{  // *** 子类 覆盖 父类,  运行的 时候 运行的 是 子类 方法.
102     
103     public void run(){
104         
105         
106         System.out.pritnln("subthread run");
107     }
108     
109     
110 }
111 
112 
113 Runnable r = new Runnable();
114 {
115     
116         public void run(){
117             
118             
119             System.out.println("runnable run");
120             
121         }
122     
123 }
124 //Thread t = new Thread(r);
125 
126 SubThread t = new SubThread(r);
127 
128 t.start();
129 
130 
131 // *** 这里先 调用 start  方法, 然后 调用 run 方法, 然后 判断  r  不为空, 然后 调用 Runnable 的 run 方法(因为 传进去的 参数 是 Runnable 的 对象 r), 然后 输出 runnable run.
132 
133 
134 */

关于 Java 中多线程的面试问题 详解

猜你喜欢

关于 Java 中多线程的面试问题详解