JAVA多线程中的常用方法_public void run() continue outside of loop

JAVA多线程中的常用方法

1.public void run（）
直接使用调用run方法并没有启动线程 仅仅只是相当于调用了对象的一个普通方法

2.public void start（）
启动线程并且调用run方法

public class TestMyThread extends Thread{
    public static void main(String[] args) {
        Thread myThread = new TestMyThread();
        myThread.setName("分支线程");
        myThread.start();  //开启线程
        for (int i = 0; i < 1000; i++) {
            System.out.println(Thread.currentThread().getName()+"线程---->"+i);
        }
    }
    
    //重写Thread类中的run方法
    @Override
    public void run() {
        for (int i = 0; i < 1000; i++) {
            System.out.println(Thread.currentThread().getName()+"---->"+i);
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

测试结果：
从测试结果看 分支线程和主线程出现了争抢cpu时间片的情况，所以由此可见start方法确实开启了线程

3. public static void sleep(long millis)
实现从进入休眠状态，线程阻塞
调用了sleep方法的当前线程进入休眠

public class TestMyThread extends Thread{
    public static void main(String[] args) {
        Thread myThread = new TestMyThread();
        myThread.setName("分支线程");
        myThread.start();  //开启线程
        for (int i = 0; i < 1000; i++) {
            System.out.println(Thread.currentThread().getName()+"线程---->"+i);
        }
    }

    //重写Thread类中的run方法
    @Override
    public void run() {
        try {
            Thread.sleep(500);  //分支线程开始睡眠，因此前500ms只有main线程执行
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName()+"睡眠结束开始执行操作");
        for (int i = 0; i < 1000; i++) {
            System.out.println(Thread.currentThread().getName()+"---->"+i);
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

测试结果：
从测试结果看Main先执行 直到分支线程醒过来之后分支线程才开始执行
4. public static Thread currentThread()
获取当前的线程对象，也就是获取到执行该方法的线程对象

5. public static void yield()
让当前线程暂停，回到就绪状态，给其他线程机会

public class TestMyThread extends Thread{
    public static void main(String[] args) {
        Thread myThread = new TestMyThread();
        myThread.setName("分支线程");
        myThread.start();  //开启线程
        for (int i = 0; i < 1000; i++) {
            System.out.println(Thread.currentThread().getName()+"线程---->"+i);
        }
    }

    //重写Thread类中的run方法
    @Override
    public void run() {
        for (int i = 0; i < 1000; i++) {
            if(i%100==0){
                Thread.yield();//如果是100的倍数就让位一下 让main线程执行
            }
            System.out.println(Thread.currentThread().getName()+"---->"+i);
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

测试结果：
从测试结果可以看出分支线程在 i 为200的时候让位了 main线程在执行

6.public void interrupt()
中断线程的休眠状态，使线程回到就绪状态

public class TestMyThread extends Thread{
    public static void main(String[] args) {
        Thread myThread = new TestMyThread();
        myThread.setName("分支线程");
        myThread.start();  //开启线程
        for (int i = 0; i < 1000; i++) {
            System.out.println(Thread.currentThread().getName()+"线程---->"+i);
        }
        System.out.println(Thread.currentThread().getName()+"线程活干完了");
        // 当主线程for循环执行完之后 唤醒分支线程 本质是使sleep方法异常从而中断休眠
        myThread.interrupt();
    }

    //重写Thread类中的run方法
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName()+"---->"+"睡前");
            try {
                Thread.sleep(1000*60*60*24*365);  //让分支线程休眠一年
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        System.out.println(Thread.currentThread().getName()+"---->"+"醒来");
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

测试结果:
这种中断睡眠的方式靠的是异常处理机制
调用interrupt方法会使sleep方法出现异常从而结束休眠

7.public final void join()
合并线程 将调用join方法的线程合并到当前线程中,使得当前线程阻塞
当前线程要等待并入的线程执行完毕之后才执行

public class TestMyThread extends Thread{
    public static void main(String[] args) {
        Thread myThread = new TestMyThread();
        myThread.setName("分支线程");
        myThread.start();  //开启线程
        try {
            myThread.join();  //将分支线程合并到Main线程中
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName()+"线程开始执行");
        for (int i = 0; i < 6; i++) {
            System.out.println(Thread.currentThread().getName()+"线程---->"+i);
        }
    }

    //重写Thread类中的run方法
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.println(Thread.currentThread().getName()+"----->"+i);
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

测试结果：
从测试结果可以看出分支线程执行完了之后 main线程才会执行