0601

🎈Java多线程

⭐基本概念

程序(program)

是为完成特定任务、用某种语言编写的一组指令的集合。即指一段静态的代码，静态对象。

进程(process)

是程序的一次执行过程，或是正在运行的一个程序。是一个动态的过程：有它自身的产生、存在和消亡的过程。——生命周期
1. 如：运行中的QQ，运行中的MP3播放器
2. 程序是静态的，进程是动态的
3. 进程作为资源分配的单位，系统在运行时会为每个进程分配不同的内存区域

线程(thread)

进程可进一步细化为线程，是一个程序内部的一条执行路径。
1. 若一个进程同一时间并行执行多个线程，就是支持多线程的
2. 线程作为调度和执行的单位，每个线程拥有独立的运行栈和程序计数器(pc)，线程切换的开销小 .
3. 一个进程中的多个线程共享相同的内存单元/内存地址空间它们从同一堆中分配对象，可以访问相同的变量和对象。这就使得线程间通信更简便、高效。但多个线程操作共享的系统资源可能就会带来安全的隐患。

⭐多线程程序的优点

提高应用程序的响应。对图形化界面更有意义，可增强用户体验。
提高计算机系统CPU的利用率
改善程序结构。将既长又复杂的进程分为多个线程，独立运行，利于理解和修改

⭐ cpu线程数和Java多线程

线程是CPU级别的，单个线程同时只能在单个cpu线程中执行
Java多线程并不是由于cpu线程数为多个才称为多线程，当Java线程数大于cpu线程数，操作系统使用时间片机制，采用线程调度算法，频繁的进行线程切换。
线程是操作系统最小的调度单位，进程是资源（比如：内存）分配的最小
Java中的所有线程在JVM进程中,CPU调度的是进程中的线程

⭐ 单核CPU和多核CPU的理解

单核CPU，其实是一种假的多线程，因为在一个时间单元内，也只能执行一个线程的任务。例如：虽然有多车道，但是收费站只有一个工作人员在收费，只有收了费才能通过，那么CPU就好比收费人员。如果有某个人不想交钱，那么收费人员可以把他“挂起”（晾着他，等他想通了，准备好了钱，再去收费）。但是因为CPU时间单元特别短(4.1Ghz)，因此感觉不出来。
如果是多核的话，才能更好的发挥多线程的效率。（现在的服务器都是多核的）
一个Java应用程序java.exe，其实至少有三个线程：main()主线程，gc()垃圾回收线程，异常处理线程。当然如果发生异常，会影响主线程。

🌟并行与并发

并行:多个CPU同时执行多个任务。比如：多个人同时做不同的事。
并发：一个CPU(采用时间片)同时执行多个任务。

比如：秒杀、多个人做同一件事。

🌟需要多线程的情况

程序需要同时执行两个或多个任务。
程序需要实现一些需要等待的任务时，如用户输入、文件读写

操作、网络操作、搜索等。

需要一些后台运行的程序时。

🕺 多线程的创建方式1/4：创建继承于Thread的子类

创建一个继承于Thread类的子类
重写Thread类的run() -->主要针对方法体，将要执行的操作写入到run()中。
创建thread的子类的对象
通过此对象调用start()
1. 启动当前线程
2. 调用当前线程的run()方法
3. 直接调用run()不会多分线程，会在main线程中进行
想要启动多个线程，需要new 多个MyThread对象

package pers.dhx_.java0601;

/**
 * 多线程的创建方式
 * 1.创建一个继承于Thread类的子类
 * 2.重写Thread类的run()
 * 3.创建thread的子类的对象
 * 通过此对象调用start()
 */
public class ThreadTest {
    public static void main(String[] args) {
        MyThread A1 = new MyThread();
        A1.start();
        MyThread A2 = new MyThread();
        A2.start();
        System.out.println("hello");
        System.out.println("hello");
        System.out.println("hello");
        for (int i = 0; i < 10; i++) {
            if ((i + 1) % 2 == 0)
                System.out.println(i + "***main _Thread****");
        }
    }
}

class MyThread extends Thread {
    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            if (i % 2 == 0)
                System.out.print(i);
            System.out.println(this.getContextClassLoader());
        }
    }
}

✋练习

目的：创建2个线程，分别遍历奇偶数

写2个Thread子类，分别orverride run()
利用匿名对象

package pers.dhx_.java0601;

public class ThreadTest {
    public static void main(String[] args) {
        MyThread_1 A1 = new MyThread_1();
        A1.start();
        MyThread_2 A2 = new MyThread_2();
        A2.start();
        System.out.println("hello");
        System.out.println("hello");
        System.out.println("hello");
        for (int i = 0; i < 10; i++) {
            if ((i + 1) % 2 == 0)
                System.out.println(i + "***main _Thread****");
        }
        new Thread() {
            @Override
            public void run() {
                for (int i = 0; i < 10000; i++) {
                    if ((i - 1) % 2 == 0)
                        System.out.print(i);
                    System.out.println(this.getClass());
                }
            }
        }.start();

    }
}
class MyThread_1 extends Thread {
    @Override
    public void run() {
        for (int i = 0; i < 10000; i++) {
            if (i % 2 == 0)
                System.out.print(i);
            System.out.println(this.getClass());
        }
    }
}

class MyThread_2 extends Thread {
    @Override
    public void run() {
        for (int i = 0; i < 10000; i++) {
            if ((i - 1) % 2 == 0)
                System.out.print(i);
            System.out.println(this.getClass());
        }
    }
}

🍅注意点：

如果自己手动调用run()方法，那么就只是普通方法，没有启动多线程模式。
run()方法由JVM调用，什么时候调用，执行的过程控制都有操作系统的CPU调度决定。
想要启动多线程，必须调用start方法。
一个线程对象只能调用一次start()方法启动，如果重复调用了，则将抛出以上的异常“IllegalThreadStateException”。

🍅Thread类的有关方法

void start(): 启动当前线程。调用当前线程的run()run(): 通常需要overrideThread类中的run()方法，将创建的线程要执行的操作声明在run()中
String getName(): 返回线程名称
void setName(String name):设置线程名称
static Thread currentThread():
- 返回当前线程。在Thread子类中就是this，通常用于主线程和Runnable实现类
static void yield()：
- 暂停当前正在执行的线程，把执行机会让给优先级相同或更高的线程。
- 若队列中没有同优先级的线程，忽略此方法
join() : 当线程a中调用b的 join() 方法时，a将被阻塞，直到b线程执行完为止 ( 低优先级的线程也可以获得执行)
static void sleep(long millis)：
- (指定时间:毫秒) 令当前活动线程在指定时间段内放弃对CPU控制,使其他线程有机会被执行,时间到后重排队。
- 抛出InterruptedException异常
stop(): 强制线程生命期结束，不推荐使用
boolean isAlive() ：返回boolean，判断线程是否还活着

package pers.dhx_.java0601;

/**
 * 测试Thread中的常用方法
 * 1.start() :启动当前线程。调用当前线程的run()
 * 2.run()通常需要overrideThread类中的run()方法，将创建的线程要执行的操作声明在run()中
 * 3.currentThread()： static method返回当前执行代码的线程
 * 4.getName()返回当前执线程的名字
 * 5.setName()设置当前执线程的名字
 * 6.yield() 释放当前cpu的执行权 (让别的线程优先）
 * 7.join() 当线程a中调用b的 join() 方法时，a将
 * 被阻塞，直到b线程执行完为止 ( 低优先级的线程也可以获得执行)
 * 8.stop():已过时， 强制线程生命期结束，不推荐使用
 */
public class ThreadMethodTest {
    public static void main(String[] args) {
        MyThread test = new MyThread(" my _Thread");
        Thread.currentThread().setName("main_Thread");
//        test.setName("我的线程");
        test.start();
        for (int i = 1; i < 100; i++) {
            if (i % 2 == 0)
                System.out.println(Thread.currentThread().getName() + ":" + i);
            if (i % 20 == 0) {
//                try {
//                    test.join();
//                } catch (InterruptedException e) {
//                    e.printStackTrace();
//                }
//                test.stop();
                try {
                    Thread.sleep(500);
                    //sleep(500);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

class MyThread extends Thread {
    public MyThread(String name) {
        super(name);
    }

    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            if (i % 2 == 0)
                System.out.println(Thread.currentThread().getName() + ":" + i);
//            if (i % 20 == 0)
//                yield();
        }
    }

}

🍅线程优先级的设置

线程的优先级等级

MAX_PRIORITY：10
MIN _PRIORITY**：**1
NORM_PRIORITY：5

涉及的方法 (both non-static)
1. getPriority()：返回线程优先值
2. setPriority(int newPriority) *改变线程的优先级

✋注意点：

优先级不绝对，依然会有交叉
只能说高优先级的线程要抢占cpu的执行权，但是只是抢占，概率较高

package pers.dhx_.java0601;
public class ThreadMethodTest {
    public static void main(String[] args) {
        MyThread test = new MyThread(" my _Thread");
        Thread.currentThread().setName("main_Thread");
        test.setPriority(Thread.MAX_PRIORITY);
        test.start();
        Thread.currentThread().setPriority(Thread.MIN_PRIORITY);
        for (int i = 1; i < 100; i++) {
            if (i % 2 == 0)
  System.out.println(Thread.currentThread().getName() + ":" + i);
        }

    }
}

class MyThread extends Thread {
    public MyThread(String name) {
        super(name);
    }
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            if (i % 2 == 0)
System.out.println(Thread.currentThread().getName() + ":" + i);
        }
    }

}
//    my _Thread:0
//        main_Thread:2
//        my _Thread:2
//        main_Thread:4
//        my _Thread:4
//        main_Thread:6
//        my _Thread:6
//        main_Thread:8
//        my _Thread:8
//        main_Thread:10
//        my _Thread:10
//        main_Thread:12
//        my _Thread:12
//        main_Thread:14
//        my _Thread:14
//        main_Thread:16
//        my _Thread:16
//        main_Thread:18
//        my _Thread:18
//        main_Thread:20
//        my _Thread:20

⭐ 说明

线程创建时继承父线程的优先级
低优先级只是获得调度的概率低，并非一定是在高优先级线程之后才被调用

⭐抢票:By method 1

package pers.dhx_.java0601;

public class WinodwsSaleTicket {
    public static void main(String[] args) {
        Thread1 t1 = new Thread1("线程1");
        Thread1 t2 = new Thread1("线程2");
        Thread1 t3 = new Thread1("线程3");
        t1.start();
        t2.start();
        t3.start();
        try {
            Thread.currentThread().sleep(2000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("线程1: " + Thread1.test.cnt_1);
        System.out.println("线程2: " + Thread1.test.cnt_2);
        System.out.println("线程3: " + Thread1.test.cnt_3);
    }


}

class Thread1 extends Thread {
    @Override
    public void run() {
        while (total != 0) {
            System.out.println(getName() + "  sale 票号: " + total--);
            if (this.getName() == "线程1") test.cnt_1++;
            else if (this.getName() == "线程2") test.cnt_2++;
            else test.cnt_3++;
        }

    }

    static Thread1 test = new Thread1("tets");
    public int cnt_1 = 0;
    public int cnt_2 = 0;
    public int cnt_3 = 0;
    public static int total = 100;
    Thread1(String name) {
        super(name);
    }

}

💃多线程的创建方式2/4: 实现Runnable 接口

创建一个实现了Runnable接口的类
实现类去实现Runnable中的抽象方法
创建实现类的对象
将此对象作为参数传递到Thread类的构造器中，创建Thread类的对象
- ⭐public Thread(Runnable target)
通过Tread类的对象调用start();

package pers.dhx_.java0601;

public class RunnableTest {
    public static void main(String[] args) {
        MThread mThread1 = new MThread();
        Thread t1 = new Thread(mThread1); //利用多态兴性
        t1.setName("线程1");
        MThread mThread2 = new MThread();
        Thread t2 = new Thread(mThread2); //利用多态兴性
        t2.setName("线程2");
        t2.start();
        t1.start();

    }
}

class MThread implements Runnable {

    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            if (i % 2 == 0)
                System.out.println(Thread.currentThread().getName() + " :" + i);
        }
    }

    MThread() {
    }
}

🌟抢票:By method 2 :Runnalbe

package pers.dhx_.java0601;

public class WinodwsSaleTicket {
    public static void main(String[] args) {
        Thread1 t1 = new Thread1();
//        Thread1 t2 = new Thread1();
//        Thread1 t3 = new Thread1();
        // olny need 1 Thread1 Object
        Thread tt1 = new Thread(t1);
        Thread tt2 = new Thread(t2);
        Thread tt3 = new Thread(t3);
        tt1.setName("线程1");
        tt2.setName("线程2");
        tt3.setName("线程3");
        tt1.start();
        tt2.start();
        tt3.start();
        try {
            Thread.currentThread().sleep(2000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("线程1: " + Thread1.test.cnt_1);
        System.out.println("线程2: " + Thread1.test.cnt_2);
        System.out.println("线程3: " + Thread1.test.cnt_3);
    }


}

class Thread1 implements Runnable {
    @Override
    public void run() {
        while (total != 0) {
            System.out.println(Thread.currentThread().getName() + " :票号 " + total--);
            if (Thread.currentThread().getName() == "线程1") test.cnt_1++;
            else if (Thread.currentThread().getName() == "线程2") test.cnt_2++;
            else test.cnt_3++;
        }

    }

    static Thread1 test = new Thread1();
    public int cnt_1 = 0;
    public int cnt_2 = 0;
    public int cnt_3 = 0;
    public  int total = 100;
}