时间：   |   分类：     |   阅读： 1801 字 ~4分钟

1. 进程和线程基础概念

  • 进程:是正在运行的程序

    是系统进行资源分配和调用的独立单位,每一个进程都有它自己的内存空间和系统资源

  • 线程:是进程中的单个顺序控制流,是一条执行路径,如扫雷种的几时,和记录雷个数就是两个不同线程
    • 单线程:一个进程如果只有一条执行路径,则称为单线程程序
    • 多线程:一个进程如果有多条执行路径,则称为多线程程序

2. 继承Thread类来实现多线程

方法名 说明
void run() 在线程开启后,此方法将被调用执行
void start() 使此线程开始执行,Java虚拟机会调用run方法()
  1. 定义一个类MyThread继承Thread类
  2. 在MyThread类中重写run()方法
  3. 创建MyThread类的对象
  4. 通过start()来启动线程==>底层是Java虚拟机来调用run()方法

2.1. 注意事项

  1. run()是用来封装被线程执行的代码
  2. 直接调用run():封装线程执行的代码,直接调用,相当于普通方法的调用
  3. start():启动线程；然后由JVM调用此线程的run()方法

2.2. 设置和获取线程名

方法名 说明
void setName(String name) 将此线程的名称更改为等于参数name
String getName() 返回此线程的名称
Thread currentThread() 返回对当前正在执行的线程对象的引用

2.3. 线程优先级

线程调度有两种调度方式

  • 分时调度模型:所有线程轮流使用 CPU 的使用权,平均分配每个线程占用 CPU 的时间片
  • 抢占式调度模型:优先让优先级高的线程使用 CPU,如果线程的优先级相同,那么会随机选择一个,优先级高的线程获取的 CPU 时间片相对多一些

    Java使用的是抢占式调度模型

随机性

假如计算机只有一个 CPU,那么 CPU 在某一个时刻只能执行一条指令,线程只有得到CPU时间片,也就是使用权,才可以执行指令.所以说多线程程序的执行是有随机性,因为谁抢到CPU的使用权是不一定的

方法名 说明
final int getPriority() 返回此线程的优先级
final void setPriority(int newPriority) 更改此线程的优先级 ,线程默认优先级是5；线程优先级的范围是:1-10,这个1~10也只是提交几率.设置好了再start效果更好

2.4. 线程的控制

方法名 说明
static void sleep(long millis) 使当前正在执行的线程停留(暂停执行)指定的毫秒数
void join() 等待这个线程死亡
void setDaemon(boolean on) 将此线程标记为守护线程,当main线程运行完(运行的线程都是守护线程时),Java虚拟机将退出

2.5. 上面所有的例子

在指定线程类种使用.一般就会让多个线程和谐执行

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

  @Override
  public void run() {
    for (int i = 0; i < 50; i++) {
      System.out.println(getName() + ":" + i);
      try {
        Thread.sleep(10);
      } catch (InterruptedException e) {
        e.printStackTrace();
      }
    }
  }
}

//------

public class Test {
  public static void main(String[] args) {
    MyThread my1 = new MyThread();
    MyThread my2 = new MyThread("高铁");
    MyThread my3 = new MyThread("汽车");
    my1.setName("飞机");

    Thread.currentThread().setName("计时器:30s");
    my1.setPriority(10);

    my1.start();
    try {
      my1.join();
    } catch (InterruptedException e) {
      e.printStackTrace();
    }
    //守护进程必须一起设置.只设置一个my2或my3没效果
//    my2.setDaemon(true);  //设置守护进程后,首先my1,因为它join了,然后my2,my3和for循环一起.循环结束后,my2和my3停止
//    my3.setDaemon(true);  //不设置搜狐进程,............................直到my2,my3执行完成才推出
    my2.start();
    my3.start();

    for (int i = 0; i < 10; i++) {
      try {
        Thread.currentThread().sleep(20);
      } catch (InterruptedException e) {
        e.printStackTrace();
      }
      System.out.println(Thread.currentThread().getName());
    }
  }
}

2.6. 线程的生命周期

线程一共有五种状态,线程在各种状态之间转换.

生命周期

3. Runnable接口实现多线程

方法名 说明
Thread(Runnable target) 分配一个新的Thread对象
Thread(Runnable target, String name) 分配一个新的Thread对象

实现步骤

  • 定义一个类MyRunnable实现Runnable接口
  • 在MyRunnable类中重写run()方法
  • 创建MyRunnable类的对象
  • 创建Thread类的对象,把MyRunnable对象作为构造方法的参数
  • 启动线程
public class MyRunnable implements Runnable {
  @Override
  public void run() {
    for (int i = 0; i < 100; i++) {
      System.out.println(Thread.currentThread().getName() + ":" + i);
    }
  }
}

//-----

public class Test {
  public static void main(String[] args) {
    MyRunnable mr = new MyRunnable();
    Thread t1 = new Thread(mr, "飞机");//名字是可选参数
    Thread t2 = new Thread(mr, "高铁");
    t1.start();
    t2.start();
  }
}

4. 总结

多线程的实现方案有两种

  1. 继承Thread类
  2. 实现Runnable接口

    相比继承Thread类,实现Runnable接口的好处

    • 避免了Java单继承的局限性
    • 适合多个相同程序的代码去处理同一个资源的情况,把线程和程序的代码,数据有效分离,较好的体现了面向对象的设计思想
0%