Java 细节汇总(1)-线程多次调用 start 方法的问题

╰+攻爆jí腚メ 2024-04-18 21:04 11阅读 0赞

#### 文章目录 ####

*  1. 线程多次调用 start 方法
 *   *   *  阻塞与等待的区别
 *  2. finally 块 return 问题
 *  3. sleep(n) 和 sleep(0)的区别
 *  4. 嵌套 for 循环性能比较
 *  5. Java 泛型实现
 *  6. 子类调用父类构造方法

## 1. 线程多次调用 start 方法 ##

从源码来看， 一个线程如果已经调用过 start 方法，那么再次调用 start 方法的时候会抛出 IllegalThreadStateException 异常， 涉及的技术点为线程的状态切换。

public synchronized void start() {
        
              // threadStatus = 0 表示这个线程有没有被执行过，如果已经执行过一次了，不允许重新启动
            if (threadStatus != 0)
                throw new IllegalThreadStateException();
            ......
        }
    // Thread 状态切换
    public State getState() {
        
            // get current thread state
            return sun.misc.VM.toThreadState(threadStatus); 
        }
    // sun.misc.VM.toThreadState 方法会使用位运算 & 更新 Thread 成员变量 threadStatus
    public static State toThreadState(int var0) {
        
            if ((var0 & 4) != 0) {
        
                return State.RUNNABLE;
            } else if ((var0 & 1024) != 0) {
        
                return State.BLOCKED;
            } else if ((var0 & 16) != 0) {
        
                return State.WAITING;
            } else if ((var0 & 32) != 0) {
        
                return State.TIMED_WAITING;
            } else if ((var0 & 2) != 0) {
        
                return State.TERMINATED;
            } else {
        
                return (var0 & 1) == 0 ? State.NEW : State.RUNNABLE;
            }
        }

#### 阻塞与等待的区别 ####

*  **阻塞**  
    当一个线程试图获取对象锁（即synchronized），而该锁被其他线程持有，则该线程进入阻塞状态。该状态线程由JVM调度器来决定是否唤醒，而不需要由另一个线程来显式唤醒，不响应中断。
 *  **等待**  
    当一个线程需等待另一个线程发出信号从而进入可执行状态时，该线程进入等待状态，该状态可响应中断。 例如调用：Object.wait()、Thread.join()及等待Lock或Condition。

需要注意虽然synchronized和JUC里的Lock都实现锁的功能，但线程进入的状态不一样。synchronized会让线程进入阻塞态，而JUC里的Lock是用LockSupport.park()/unpark()来实现阻塞/唤醒的，会让线程进入等待态。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NTUwNTMxMw_size_16_color_FFFFFF_t_70]

## 2. finally 块 return 问题 ##

finally 语句块最后执行，如果没有在 finally 语句中执行 return，则以之前 return 返回的值为准

public static int test() {
        
        int i = 1;
        try {
        
        	return i; // 此时 return 返回值已经确定为 1 ，但是该方法还没有执行完毕
        } finally {
        
        	i += 1;// finally里的变量 i 不能改变之前的 return 的 i 的值
        }
    }
    
    public static int test() {
        
        try {
        
            return 1; 
        } finally {
        
            return 2; // finally 语句最后执行，此时 return 2 
        }
    }

## 3. sleep(n) 和 sleep(0)的区别 ##

调用 sleep 接口会有条件地将调用线程从当前处理器上移除，并且有可能将它从线程调度器的可运行队列中移除，这个条件取决于调用 sleep 时 timeout 参数。

*  当 timeout = 0， 即 sleep(0)，如果线程调度器的可运行队列中有大于或等于当前线程优先级的就绪线程存在，操作系统会将当前线程从处理器上移除，调度其他优先级高的就绪线程运行；如果可运行队列中的没有就绪线程或所有就绪线程的优先级均低于当前线程优先级，那么当前线程会继续执行，就像没有调用 sleep(0)一样
 *  当 timeout > 0 时，如：sleep(1)，会引发线程上下文切换：调用线程会从线程调度器的可运行队列中被移除一段时间，这个时间段约等于 timeout 所指定的时间长度。通常情况下，系统的时间精度为 10 ms，那么指定任意少于 10 ms但大于 0 ms 的睡眠时间，均会向上求值为 10 ms

## 4. 嵌套 for 循环性能比较 ##

计算表达式相同时，以下两个循环所计算得到的结果完全相同，但是从循环所需的计算次数来看，第二个循环性能是优于第一个的。

可以明显看出来，对于内部循环 j 来说，无论哪种写法操作次数都是一样；但是对外循环 i 来说，第2 种写法操作次数显著减少，性能相对更高。

*  循环嵌套的原则：外层循环的次数应该尽量小

参考： https://blog.csdn.net/lengxiao\_wang/article/details/636895

1.for ( i= 0;  i < 10000;  i++)
          for (j =0; j < 100; j++) {
        
          // TODO
          }
          
    2. for ( i= 0;  i < 100;  i++)
          for (j =0; j < 10000; j++){
        
          // TODO
          }

## 5. Java 泛型实现 ##

Java 中的泛型是 伪泛型，对于 List< Integer > 和 List< String > 两种写法，编译后的字节码中已经替换为原来的原生类型 List，这就是Java中的 泛型擦除。

`对于 List<String> list = new ArrayList<>()`  
`编译后的 class 文件中其实已经变成 List list = new ArrayList()`  
`访问元素的时候则会加上强制类型转换, (String) list.get(0);`

因为这种实现方式，以下重载会在编译之前就报出 `both method have same erasure`错误

void getArray(List<String> list){
        }
    void getArray(List<Integer> list){
        }

## 6. 子类调用父类构造方法 ##

子类所有的构造方法都会默认访问父类的无参构造方法，因为子类可能用到父类中的数据，所以父类数据初始化必须先于子类进行，但是不会产生父类对象  
需注意，一般情况编译器会默认为 Java 类提供无参构造方法，但如果类中声明了有参构造，则不会有默认无参的构造方法，此时需要在子类构造方法第一行显式调用父类构造方法

public class A {
        
        private int m;
        public A (int m) {
        
    		this.m = m;
    	}
    }
    
    public class B extend A {
        
    
        public B () {
        
        	// super(); // 在第一行默认调用父类无参构造
        	// 如父类没有无参构造方法，则需显式调用
        	super(10);
    	}
    }

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NTUwNTMxMw_size_16_color_FFFFFF_t_70]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/18/7684a2a2b3a24c5998079059c9043f89.png