Java学习笔记——34多线程01

实现多线程

进程和线程的区别

进程：是正在运行的程序

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

• 线程：是进程中的单个顺序控制流，是一条执行路径

• 单线程：一个进程只有一条执行路径
• 多线程：一个进程有多条执行路径

• 多线程的实现方式

  在java.lang下

  方式一：继承Thread类

  • 定义一个类MyThread继承Thread类
  • 在MyThread中重写run()方法，因为run()方法是用来封装被执行线程的代码
  • 创建MyThread类对象
  • 启动线程

  public class ThreadDemo {
      public static void main(String[] args){
          MyThread my1=new MyThread("杨天伦");
          MyThread my2=new MyThread("李昊");
          my1.start();
          my2.start();//void start()导致线程开始执行；java虚拟机调用此线程的run方法
      }
  }
  1
  2
  3
  4
  5
  6
  7
  8

  run和start的区别：
  color=’red’> run():封装线程执行的代码，直接调用，相当于普通方法的调用
  start():启动线程;然后由JVM调用此线程的run()方法

  设置线程名称

  通过setName和getName
  带参构造方法（需要super带参调用父类构造方法）以及**Thread.currentThread().getName()**获取

  线程调度

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

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

  Thread类中提供两个方法用来设置和获取线程优先级：
  public final int getPriority):返回此线程的优先级
  public final void setPriority(int newPriority):更改此线程的优先级

  线程的优先级有范围，最高是10，最低1，默认5
  线程优先级高仅仅表示线程获取CPU时间片的几率高，需要在次数比较多，或者多次运行时才能看到效果

  线程控制

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

  sleep代码示例

  public class ThreadSleep extends Thread{
      @Override
      public void run(){
          for (int i=0;i<99;i++){
              System.out.println(getName()+":"+i);
              try {
                  Thread.sleep(1000);
              } catch (InterruptedException e) {
                  throw new RuntimeException(e);
              }
          }
      }
  }
  1
  2
  3
  4
  5
  6
  7
  8
  9
  10
  11
  12
  13

  public class ThreadSleepDemo {
      public static void main(String[] args){
          ThreadSleep ts1=new ThreadSleep();
          ThreadSleep ts2=new ThreadSleep();
          ThreadSleep ts3=new ThreadSleep();
          ts1.setName("朱长坤");
          ts2.setName("李昊");
          ts3.setName("杨天伦");
  
          ts1.start();
          ts2.start();
          ts3.start();
      }
  }
  
  1
  2
  3
  4
  5
  6
  7
  8
  9
  10
  11
  12
  13
  14
  15

  join代码示例

  public class ThreadJoin extends Thread{
      @Override
      public void run(){
          for (int i=0;i<99;i++){
              System.out.println(getName()+":"+i);
          }
      }
  }
  
  1
  2
  3
  4
  5
  6
  7
  8
  9

  public class ThreadJoinDemo {
      public static void main(String[] args) {
          ThreadJoin tj1=new ThreadJoin();
          ThreadJoin tj2=new ThreadJoin();
          ThreadJoin tj3=new ThreadJoin();
  
          tj1.setName("李昊");
          tj2.setName("杨天伦");
          tj3.setName("朱长坤");
  
          tj1.start();
          try {
              tj1.join();
          } catch (InterruptedException e) {
              throw new RuntimeException(e);
          }
          tj2.start();
          tj3.start();
  
      }
  }
  1
  2
  3
  4
  5
  6
  7
  8
  9
  10
  11
  12
  13
  14
  15
  16
  17
  18
  19
  20
  21

  setDaemon代码示例

  public class ThreadDaemon extends Thread {
      @Override
      public void run(){
          for (int i=0;i<99;i++){
              System.out.println(getName()+":"+i);
          }
      }
  }
  1
  2
  3
  4
  5
  6
  7
  8

  public class ThreadDaemonDemo {
      public static void main(String[] args) {
          ThreadDaemon td1=new ThreadDaemon();
          ThreadDaemon td2=new ThreadDaemon();
  
          td1.setName("李昊");
          td2.setName("杨天伦");
          Thread.currentThread().setName("任然");
          td1.setDaemon(true);
          td2.setDaemon(true);
          td1.start();
          td2.start();
          for (int i=0;i<9;i++){
              System.out.println(Thread.currentThread().getName()+":"+i);
          }
      }
  }
  1
  2
  3
  4
  5
  6
  7
  8
  9
  10
  11
  12
  13
  14
  15
  16
  17

  线程生命周期

  

  方式二：实现Runnable接口

  • 定义一个类MyRunnable实现Runnable接口
  • 在MyRunnable类中重写run()方法
  • 创建MyRunnable类的对象
  • 创建Thread类对象，把MyRunnable对象作为构造方法的参数
  • 启动线程

  public class MyRunnable implements Runnable{
      @Override
      public void run(){
          for (int i=0;i<99;i++){
              System.out.println(Thread.currentThread().getName()+":"+i);
          }
      }
  }
  
  1
  2
  3
  4
  5
  6
  7
  8
  9

  public class MyRunnableDemo {
      public static void main(String[] args) {
          MyRunnable my=new MyRunnable();
  
          Thread t1=new Thread(my,"杨天伦");
          Thread t2=new Thread(my,"李昊");
          t1.start();
          t2.start();
      }
  }
  1
  2
  3
  4
  5
  6
  7
  8
  9
  10

  相比于Thread，实现Runnable接口的好处

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