JAVA---多线程

• 程序（program） 是为完成特定任务、用某种语言编写的一组指令的集合。即指一段静态的代码。
• 进程 （process） 是程序的一次执行过程，或是正在运行的一个程序。是一个动态的过程：有它自身的产生、存在和消亡的过程。--生命周期
• 线程（thread）进程可进一步细化为线程，是一个程序内部的一条执行路径。
  • 若一个进程同一时间并行执行多个线程，就是支持多线程的
  • 线程作为调度和执行的单位，每个线程拥有独立的运行栈和程序计数器，线程切换的开销小。
  • 一个进程中的多个线程共享相同的内存单元/内存地址空间---他们从同一堆中分配对象，可以访问相同的变量和对象。这使得线程间通信更简便、高效。但多个线程操作共享的系统资源可能会带来安全的隐患。
• 并行：多个CPU同时执行多个任务。
• 并发：一个CPU（采用时间片）同时执行多个任务。

package nkc;

/**
 * 多线程的创建，方式一：继承于Thread类
 * 1.创建一个继承于Threadl类的子类
 * 2.重写Thread类的run()--->将此线程执行的操作声明在run()中
 * 3.创建Thread类的子类的对象
 * 4.通过此对象调用start()
 *
 * 例子：遍历100以内所有的偶数
 *
 * @author nkc
 * @create 2022-03-10 21:18
 */
class MyThread extends Thread{
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            if(i%2==0){
                System.out.println(Thread.currentThread().getName()+":"+i);
            }
        }
    }
}
public class ThreadTest {
    public static void main(String[] args) {
        MyThread t1=new MyThread();

        t1.start();
        //再启动一个线程
        MyThread t2=new MyThread();

        t2.start();

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

package nkc;

/**
 * 练习：创建两个分线程，其中一个线程遍历100以内的偶数，另一个线程遍历100以内的奇数
 * @author nkc
 * @create 2022-03-10 21:37
 */
public class ThreadDemo {
    public static void main(String[] args) {

//        MyThread1 thread1=new MyThread1();
//        MyThread2 thread2=new MyThread2();
//        thread1.start();
//        thread2.start();
        //创建Thread类的匿名子类的方式
        new Thread(){
            @Override
            public void run() {
                for (int i = 0; i < 100; i++) {
                    if(i%2==0){
                        System.out.println(Thread.currentThread().getName()+":"+i);
                    }
                }
            }
        }.start();

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

    }


}
class MyThread1 extends Thread{
    @Override
    public void run() {
        for (int i = 0; i <100; i++) {
            if(i%2==0){
                System.out.println(Thread.currentThread().getName()+":"+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().getName()+":"+i);
            }
        }
    }
}

package nkc;

/**
 * Thread中的常用方法：
 * 1.start():启动当前线程；调用当前线程的run()
 * 2.run():通常要重写Thread类中的此方法，将创建的线程要执行的操作声明在此方法中
 * 3.currentThread():静态方法，返回执行当前代码的线程。
 * 4.getName():获取当前线程的名字
 * 5.setName():设置当前线程的名字
 * 6.yield():释放当前CPU的执行权
 * 7.join():在线程a中调用线程b的join(),此时线程a就进入阻塞状态，直到线程b完全执行完以后，线程a才结束阻塞状态。
 * 8.stop():已过时。当执行此方法时，强制结束当前进程。
 * 9.sleep(long milltime):让当前线程“睡眠”指定的milltime毫秒。在指定的milltime毫秒时间内，当前线程是阻塞状态。
 * 10.isAlive():判断当前线程是否存活。
 *
 * 线程的优先级：
 * 1.
 * MAX_PRIORITY     10
 * MIN_PRIORITY     1
 * NORM_PRIORITY    5--->默认优先级
 *
 * 2.如何获取和设置当前线程的优先级
 *  getPriority():获取线程的优先级
 *  setPriority(int p):设置线程的优先级
 *
 *  说明：高优先级的线程要抢占低优先级线程cpu的执行权。但是只是从概率上讲，高优先级的线程会有更高概率被执行。并不意味着
 *      只有当高优先级的线程执行完以后，低优先级的线程才执行。
 *
 *
 * @author nkc
 * @create 2022-03-11 11:07
 */

class HelloThread extends Thread{
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            if(i%2==0){
                try {
                    sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName()+":"+Thread.currentThread().getPriority()+":"+i);
            }
            if(i%20==0){
                yield();
            }
        }

    }
    public HelloThread(String name){
        super(name);
    }
}

public class ThreadMethodTest {
    public static void main(String[] args) {
        HelloThread h1=new HelloThread("Thread:1");

        //h1.setName("线程一");
        h1.setPriority(Thread.MAX_PRIORITY);

        h1.start();

        Thread.currentThread().setName("主线程");
        Thread.currentThread().setPriority(Thread.MIN_PRIORITY);

        for (int i = 0; i < 100; i++) {
            if (i%2==0){
                System.out.println(Thread.currentThread().getName()+":"+Thread.currentThread().getPriority()+":"+i);
            }
            if(i==20){
                try {
                    h1.join();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }

        System.out.println(h1.isAlive());
    }
}

package nkc;

/**
 *
 * 创建多线程的方式二：实现Runnable接口
 * 1.创建一个实现了Runnable接口的类
 * 2.实现类去实现Runnable中的抽象方法：run()
 * 3.创建实现类的对象
 * 4.将此对象作为参数传递到Thread类的构造器中，创建Thread类的对象
 * 5.通过Thread类的对象调用start()
 *
 *
 * 比较创建线程的两种方式
 * 开发中：优先选择：实现Runnable接口的方式
 * 原因：1.实现的方式没有类的单继承性的限制
 *       2.实现的方式更适合来处理多个线程有共享数据的情况。
 *
 *
 * 联系：其实Thread类也实现了Runnable接口
 *
 * 相同点：两种方式都需要重写run(),将线程要执行的逻辑声明在run()中。
 * 
 * @create 2022-03-11 15:06
 */
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);
            }
        }
    }
}

public class ThreadTest1 {
    public static void main(String[] args) {
        MThread mThread=new MThread();
        Thread t1=new Thread(mThread);

        t1.setName("线程1");
        t1.start();

        Thread t2=new Thread(mThread);
        t2.setName("线程2");
        t2.start();
    }
}