[Js-Java SE]线程与进程

 

线程指的是进程的一个执行场景，也就是执行流程，那么进程和线程有什么区别呢？

　　· 每一个进程是一个应用程序，都有独立的内存空间

　　· 同一个进程中的线程共享进程中的内存和资源（共享的内存是堆内存和方法区内存，栈内存不共享，每个线程有自己的）

5.线程的创建和启动

/*
    在Java语言中实现多线程的第一种方式：
        第一步：继承java.lang.Thread
        第二步：重写run方法

    三个重要知识点：
        如何定义线程？
        如何创建线程？
        如何启动线程？

*/
class ThreadTest02 
{
    public static void main(String[] args) 
    {
        // 创建线程
        Thread t = new Processor();
        // 启动线程
        t.start(); // 这段代码执行瞬间结束。告诉JVM分配一个新的栈给t线程
                    // run不需要程序员手动调用，系统线程启动之后自动调用run方法
                    // 直接调用run方法会变成直接方法调用，程序只有一个主线程

        // 这段代码在主线程中运行
        for (int i = 0; i < 100; i++) {
            System.out.println("main==>" + i);
        }

        // 有了多线程之后，main方法结束只是主线程栈中没有方法栈帧了
        // 但是其他线程或者其他栈中还有栈帧
        // main方法结束，程序可能还在运行
    }
}

// 定义一个线程
class Processor extends Thread
{
    // 重写run方法
    public void run(){
        for (int i = 0; i < 100; i++) {
            System.out.println("run==>" + i);
        }
    }
}

/*
    在Java语言中实现多线程的第二种方式：
        第一步：实现java.lang.Runnable接口
        第二步：重写run方法

    三个重要知识点：
        如何定义线程？
        如何创建线程？
        如何启动线程？

*/
class ThreadTest03
{
    public static void main(String[] args) 
    {
        //创建线程
        Thread t = new Thread(new Processor());

        //启动线程
        t.start();
    }

}

// 这种方式是推荐的。因为一个类实现接口之外保留了类的继承
class Processor implements Runnable
{
    public void run(){
        for (int i = 0; i < 10; i++) {
            System.out.println("run==>" + i);
        }
    }
}

 

 

6.线程的生命周期

 

新建：采用new语句创建完成

就绪：执行start之后

运行：占用CPU时间

阻塞：执行了wait语句、执行了sleep语句和等待某个对象锁，等待输入的场合

终止： 退出run方法

 

7.线程的调度与控制

　　通常我们的计算机只有一个CPU，CPU在某一个时刻只能执行一条指令，喜爱昵称只有得到CPU时间片，也就是使用权才可以执行指令，在单CPU的机器上线程不是并行运行的，只有在多个CPU上线程才可以并行运行，Java虚拟机要负责线程的调度，取得CPU的使用权，目前有两种调度模型：分时调度模型和抢占式调度模型。Java使用抢占式调度模型

　　分时调度模型：所有线程轮流使用CPU的使用权，平均分配每个线程占用CPU的时间片

　　抢占式调度模型：优先让优先级高的线程使用CPU，如果线程的优先级相同，那么会随机选择一个。优先级高的线程获取的CPU时间片相对多一些

 8.线程优先级

　　线程的优先级主要分为三种：MAX_PRIORITY（最高级），MIN_PRIORITY（最低级），NORM_PRIORITY（默认标准级别）

/*
 * 线程优先级高的获取的CPU时间片相对多一些
 * 
 * 优先级：1～10
 * 最低：1
 * 最高：10
 * 默认：5
 */
public class ThreadTest05 {

    public static void main(String[] args) {
        System.out.println(Thread.MAX_PRIORITY); //10
        System.out.println(Thread.MIN_PRIORITY); //1
        System.out.println(Thread.NORM_PRIORITY); //5
        
        Thread t1 = new Processor();
        t1.setName("t1");

        Thread t2 = new Processor();
        t2.setName("t2");

        System.out.println(t1.getPriority()); //5
        System.out.println(t2.getPriority()); //5
        
        //设置优先级
        t1.setPriority(4);
        t2.setPriority(6);
        
        //启动线程
        t1.start();
        t2.start();
    }

}

class Processor extends Thread {

    @Override
    public void run() {
        for (int i = 0; i < 50; i++) {
            System.out.println(Thread.currentThread().getName() + "-->" + i);
        }
    }

}

 

 

9.关于sleep方法需要注意的几点

　　· sleep方法的参数单位为毫秒

　　· sleep方法为静态方法，调用的时候睡眠的是调用了这个方法的线程

　　· 可以使用interrupt方法进行中断，但是interrupt是成员方法（这种方法依靠的是异常处理机制）

　　sleep的终止：

package com.neu.core;

/*
 * 打断线程的第一种方案：利用interrupt方法触发异常处理机制
 */
public class ThreadTest08 {
    public static void main(String[] args) throws InterruptedException {

        // 创建线程
        Thread t = new Thread(new Processor());
        t.setName("t");

        // 启动线程
        t.start();

        // 5秒之后
        // t.sleep(5000);起到的效果和下面一样，因为sleep方法是静态的
        Thread.sleep(5000);

        // 打断t线程的休眠
        t.interrupt();

    }
}

class Processor implements Runnable {

    @Override
    public void run() {
        try {
            Thread.sleep(5000000000L);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        for (int i = 0; i < 5; i++) {
            System.out.println(Thread.currentThread().getName() + "-->" + i);
        }
    }

}
/* 运行结果：
 * ---------- java ----------
    java.lang.InterruptedException: sleep interrupted
        at java.lang.Thread.sleep(Native Method)
        at Processor.run(ThreadTest08.java:29)
        at java.lang.Thread.run(Thread.java:748)
    t-->0
    t-->1
    t-->2
    t-->3
    t-->4
    
    Output completed (5 sec consumed) - Normal Termination
 * 
 * */

 

package com.neu;

/**
 * 打断线程的第一种方案：设置标志符
 */
public class ThreadTest09 {
    public static void main(String[] args) throws InterruptedException {
        Processor processor = new Processor();
        Thread t = new Thread(processor);

        t.setName("t");

        t.start();

        Thread.sleep(5000);

        processor.run = false;
    }
}

class Processor implements Runnable {

    boolean run = true;

    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            if (run) {
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    // e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName() + "-->" + i);
            }
        }
    }

}
/**
 * 运行结果：
 *
 * t-->0
 * t-->1
 * t-->2
 * t-->3
 * t-->4
 *
 * Process finished with exit code 0
 */