java中的多线程

线程（thread）的说明：线程做为调度和执行的单位，每个线程拥有独立的运行栈和程序计数器（pc），线程切换的开销小。

image

多个线程，共享同一个进程的结构：方法区，堆
创建多线程的方式：

一.继承Thread类的方式

1.创建一个继承Thread类的子类
2.重写Thread类中的run()，将此线程执行的操作声明在run()中
3.创建Thread类的子类的对象。
4.通过此对象调用start(): ①启动当前线程 ② 调用当前线程的run()

代码应用

 创建两个分线程，其中一个线程遍历100以内的偶数

另一个线程遍历100以内的奇数

class MyThread1 extends Thread{
    @Override
    public void run() {
        for (int i=0;i<100;i++){
            if(i%2==0) {
                System.out.println(Thread.currentThread()+ ":"+i);//获取当前线程
            }
        }
    }
}

class MyThread2 extends Thread{
    @Override
    public void run() {
        for (int i=0;i<100;i++){
            if(i%2 != 0){
                System.out.println(Thread.currentThread() + ":"+i);
            }
        }
    }
}
public class ThreadDemo {
    public static void main(String[] args) {
        MyThread1 m1 = new MyThread1();
        MyThread2 m2 = new MyThread2();

        m1.start();
        m2.start();
    }
}

运行结果：

image.png

Thread中的常用方法

1.start()：启动当前线程：调用当前线程的run方法
2.run()：通常需要重写Thread类中的此方法，将创建的线程执行的操作声明在此方法中
3.currentThread()：静态方法，返回当前代码执行的线程
4.getName()：获取当前线程的名字
5.setName()：设置当前线程的名字
6.yield()：释放当前cup的执行权
7.join()：在线程a中调用线程b的join方法，当你一旦调用完后，线程a进入阻塞状态，直到线程b完全执行完后，线程a才结束阻塞状态
8.stop():已过时，当执行此方法时，强制结束当前线程
9.sleep(Long millitime):让当前线程睡眠，指定的milltime毫秒数。在指定的时间之内，线程是阻塞状态
10.isAlive()：判断线程是否存活
线程的优先级：
MAX_PRIORITY:10
MIN_PRIORITY:1
NORM_PRIORITY:5 默认的优先级
如何获取和设置当前线程的优先级：
```
 getPriority();获取
```
```
 setPriority(int p);设置
```
说明：高优先级要抢占低优先级线程cpu的执行权，但只是从概率的情况上来讲，并不是意味着只有高优先级执行完才执行低优先级

演示

class HelloMyThread extends Thread{
    @Override
    public void run() {
        for(int i=0; i<100;i++){
            if (i%2 == 0){
//                try {
//                    sleep(10);
//                } catch (InterruptedException e) {
//                    e.printStackTrace();
//                }
                System.out.println(Thread.currentThread().getName()+ i);
            }

//            if(i%20 == 0){
//                this.yield();//this代表当前类的对象，就以下的h1
//            }
        }
    }

    public HelloMyThread(String name){
        super(name);
    }
}
public class ThreadMethodTest {
    public static void main(String[] args) {
        HelloMyThread h1 = new HelloMyThread("Thread:");

        // h1.setName("线程一");
        //设置线程的优先级
        h1.setPriority(Thread.MIN_PRIORITY);

        h1.start();

        //给主线程命名
        Thread.currentThread().setName("主线程");

        for(int i=0; i<100;i++){
            if (i%2 == 0){
                System.out.println(Thread.currentThread().getName()+ i +" " + Thread.currentThread().getPriority());
            }

            if(i==20){
                try {
                    h1.join();//用的是h1的join，暂停此线程，执行h1线程
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
        System.out.println(h1.isAlive());
    }
}

二.实现Runnable接口

1.创建一个实现类Runnable接口的类
2.实现类去实现Runnable中的抽象方法：run()
3.创建实现类的对象
4.将此对象作为参数传递到Thread类的构造器中，创建Thread类的对象
5.通过Thread类的对象调用start()

演示

//1.创建一个实现Runnable接口的类
class  MThread implements Runnable{
    //2.实现run方法
    @Override
    public void run() {
        for(int i = 0; i<100; i++){
            if(i%2 == 0){
                System.out.println(i);
            }
        }
    }
}
public class ThreadTest1 {
    public static void main(String[] args) {
        //3.创建实现类的对象
        MThread m1 = new MThread();
        // 4.将此对象作为参数传递到Thread类的构造器中，创建Thread类的对象
        Thread t1 = new Thread(m1);
        //5.通过Thread类的对象调用start() ：1.启动线程 2.调用当前线程的run()
        t1.start();
    }
}

两种方式的对比：
优先选择：实现Runnable接口的方式