2022.01.20Java多线程基础

2022.01.20多线程基础

方式一：继承Thread类

1) 定义子类继承Thread类。

2) 子类中重写Thread类中的run方法。

3) 创建Thread子类对象，即创建了线程对象。

4) 调用线程对象start方法：启动线程，调用run方法。

package www.fancy.thread;

//练习：创建两个线程，一个遍历100以内的偶数，另一个遍历100以内的奇数。

public class ThreadDemo extends Thread{

    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            if(i % 2 != 0){
                try {
                    sleep(10); //让当前线程阻塞1000毫秒
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName()+":"+i);
            }

        }
    }
}

class Test{
    public static void main(String[] args) {

        ThreadDemo threadDemo = new ThreadDemo();
        threadDemo.setName("thread-2");
        threadDemo.start();

        //创建Thread匿名子类的方式
        new ThreadDemo(){
            public void run(){
                for (int i = 100; i < 200; i++) {
                    System.out.println(Thread.currentThread().getName()+":"+i);
                    //if(i % 20 == 0){
                       // yield();            //执行到此释放当前cup的执行权

                    //}
                }
            }
        }.start();


        for (int i = 0; i < 100; i++) {
            if(i % 2 == 0){
                System.out.println(Thread.currentThread().getName()+":"+i);
            }
            if(i == 20){
                try {
                    threadDemo.join();// Thread-1线程加入执行完以后，main方法的线程才继续执行
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }

        System.out.println(threadDemo.isAlive()); //判断threadDemo线程是否还在
    }
}

以上代码运行结果：

main:0
...
main:20
Thread-1:100
...
Thread-1:199
thread-2:1
thread-2:3
thread-2:5
...
thread-2:93
thread-2:95
thread-2:97
thread-2:99
main:22
main:24
...
main:96
main:98
false

 

方式二：实现Runnable接口

1) 定义子类继承（Object）类实现Runnable接口。

2) 子类中重写Runnable接口中的run方法。

3) 创建子类对象

4) 调用Thread类中的构造器，传入该对象，构造Thread对象

5) 对该对象调用start方法

package www.fancy.thread2;

public class mThread extends Object implements Runnable{

    private int num = 0;

    public void run(){
        for (int i = 100; i <= 200; i++) {
            if(i % 2 != 0){
                num++;
                System.out.println(java.lang.Thread.currentThread().getName()+":"+i);
                System.out.println(java.lang.Thread.currentThread().getName()+"次数:"+num);

            }
        }
    }
}

class mThread1 {
    public static void main(String[] args) {
        mThread mthread=new mThread();

        Thread t1 = new Thread(mthread);
        Thread t2 = new Thread(mthread);
        Thread t3 = new Thread(mthread);

        t1.setName("set1");
        t2.setName("set2");
        t3.setName("set3");

        t1.start();
        t2.start();
        t3.start();

    }

}

以上代码运行结果：

set3:101
set2:101
set1:101
set2次数:3
set3次数:3
set2:103
set1次数:3
set2次数:5
set3:103
set3次数:7
set3:105
set3次数:8
set3:107
set3次数:9
set3:109

...
set1:199
set1次数:150

 

方法一和方法二的区别和联系：

 

 

每日一考

1.谈谈你对程序、进程、线程的理解。

程序：完成特定任务，使用特定语言编写的指令的集合；

进程：正在运行的一个程序；

线程：一个程序内部的一条执行路径。

 

2.代码完成继承Thread的方式创建分线程

3.代码完成实现Runnable接口的方法创建线程

 

4.对比两种创建方式：

二者都要重写run方法；

实现Runnable接口的方法可以多继承，大多数使用该方法。特别是对于处理共享数据的多线程。