java 多线程-1

一、程序、进程、线程简介

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

2. 进程(process)是程序的一次执行过程，或是正在运行的一个程序。是一个动态的过程：有它自身的产生、存在和消亡的过程。——生命周期

   • 如：运行中的QQ，运行中的MP3播放器
   • 程序是静态的，进程是动态的
   • 进程作为资源分配的单位，系统在运行时会为每个进程分配不同的内存区域

3. 线程(thread)，进程可进一步细化为线程，是一个程序内部的一条执行路径。

   • 若一个进程同一时间并行执行多个线程，就是支持多线程的

   • 线程作为调度和执行的单位，每个线程拥有独立的运行栈和程序计数器(pc)，线程切换的开销小。

     1. 栈和程序计数器，每个线程各自有一套
     2. 方法区、堆一个进程一份，一个进程里面有个多个线程，这也就意味这，多个线程共享方法区和堆。

     

• 一个进程中的多个线程共享相同的内存单元/内存地址空间它们从同一堆中分配对象，可以访问相同的变量和对象。这就使得线程间通信更简便、高效。但多个线程操作共享的系统资源可能就会带来安全的隐患。

二、并行与并发

并行：多个CPU同时执行多个任务。比如：多个人同时做不同的事。

并发：一个CPU(采用时间片)同时执行多个任务。比如：秒杀、多个人做同一件事。

三、线程的创建方式一 【继承Thread类】

1. Thread类的特性。

   • 每个线程都是通过某个特定Thread对象的run()方法来完成操作的，经常把run()方法的主体称为线程体。
   • 通过该Thread对象的start()方法来启动这个线程，而非直接调用run()。【直接调动run方法不是多线程】

2. Thread类构造器

   • Thread()：创建新的Thread对象
   • Thread(String threadname)：创建线程并指定线程实例名
   • Thread(Runnable target)：指定创建线程的目标对象，它实现了Runnable接口中的run方法
   • Thread(Runnable target, String name)：创建新的Thread对象

1. 继承Thread类的实现步骤

   （1）定义子类继承Thread类。

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

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

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

   public class ThreadTest {
       public static void main(String[] args) {
           MyThread myThread = new MyThread();
           myThread.start(); // 启动线程
           for (int i = 0; i < 300; i++) {
               if (i % 2 != 0) {
                   System.out.println("main："+i);
               }
           }
       }
   }
   
   class MyThread extends Thread {
       @Override
       public void run() { // 重写run方法
           for (int i = 1; i < 101; i++) {
               if (i % 2 == 0) {
                   System.out.println(i+" ");
               }
           }
       }
   
   }
   

2. Thread类的有关方法

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

四、线程的调度

1. cpu的调度策略：

• 时间片

• 抢占式：高优先级的线程抢占CPU

1. Java的调度方法：

• 同优先级线程组成先进先出队列（先到先服务），使用时间片策略
• 对高优先级，使用优先调度的抢占式策略

1. 线程的优先级

MAX_PRIORITY：10

MIN_PRIORITY：1

NORM_PRIORITY：5

涉及的方法:

• getPriority()：返回线程优先值
• setPriority(intnewPriority)：改变线程的优先级

说明：

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

五、线程的创建方式二 【方式二：实现Runnable接口】

1. 定义子类，实现Runnable接口。
2. 类中重写Runnable接口中的run方法。
3. 通过Thread类含参构造器创建线程对象。
4. 将Runnable接口的子类对象作为实际参数传递给Thread类的构造器中。
5. 调用Thread类的start方法：开启线程，调用Runnable子类接口的run方法。

public class RunnableTest {
    public static void main(String[] args) {
        RunTest runTest = new RunTest(); // new 一个实例对象
        Thread thread = new Thread(runTest); // 把实例对象传入Thread的构造器中。
        thread.start(); // 开启线程
    }
}

class RunTest implements Runnable{ // 实现Runnable接口
    @Override
    public void run() {
        for (int i = 0; i < 101; i++) {
            if (i % 2 == 0) {
                System.out.println(i);
            }
        }
    }
}

六、比较创建线程的两种方式

1. 开发中：优先选择——实现Runnable接口的方式

2. 原因：

   • 实现的方式没有类的单继承性的局限性
   • 实现的方式更适合来处理多个线程有共享数据的情况
     • 因为多个线程使用的是同一个对象。
     • 即不用加static关键字，即可处理数据共享。

3. 联系：

   • Thread 类也实现了Runnable接口
   • 两中方式都需要重写run（），将线程的要执行的逻辑声明在run()中