多线程

一.多线程实现：必须依靠一个线程的主体类，需要 继承Thread类或实现Runnable接口来完成定义。 1.5之后，Callable接口

1.继承Thread类

实现一个线程的第一种方式
1. 继承Thread
2. 重写子类的run方法  该子类应重写 Thread 类的 run  在线程中执行的代码 - Thread类run()方法的方法体
3. 创建该子类的对象
4. 启动线程 start()

1. 线程中执行代码究竟是那部分呢？
2. 一个Thread类对象 -》 线程
3. 如果要让代码在线程中执行， 不能在线程对象上.run(), 正确的方式应该是在线程 对象上调用start()
4. 对于方法而言，它在哪个线程中被调用，它就运行在调用它的线程中(执行路径)
5. 同一个线程对象只能被启动一次

package practice;

/**
 * @auther ZhangGang
 * @date 2020/1/16 21:19
 */
public class prc1 {
    public static void main(String[] args) {
        MyThread myThread = new MyThread("线程A");
        myThread.start();
    }

}
class MyThread extends Thread{
    private String name ;
    public MyThread(String name){
        this.name = name;
    }

    @Override
    public void run(){
        for (int x = 0; x < 200 ; x++){
            System.out.println(this.name + "-->" + x);
        }
    }
}
//运行结果：
线程A-->0
线程A-->1
线程A-->2

2.实现Runnable接口（有效避免单继承局限）

package practice;
/**
 * @auther ZhangGang
 * @date 2020/1/16 21:26
 *
 * 线程的第二种实现形式：
 *
 *  1.定义实现Runnable接口的子类
    2.实现Runnable接口的run方法  // 要运行咋线程中的代码就得写在实现了Runnable接口的run方法中
    3.创建该子类对象
    4.在创建Thread对象的时候，将创建好的Runnable子类对象作为初始化参数，传递给Thread对象
    5.启动Thread对象(启动线程)
      Thread(Runnable target)
      分配新的 Thread 对象。
 *
 */
public class Demo4Thread2 {
  public static void main(String[] args) {
    //3创建该子类对象
    MyRunnale myRunnale = new MyRunnale();
    Thread thread = new Thread(myRunnale);
    thread.start();
    System.out.println("main end");
  }
}
class MyRunnale implements Runnable {
  @Override
  public void run() {
    // 只有将代码下载Runnable接口的run方法中，才能在子线程中运行
    for (int i = 0; i < 100; i++) {
      System.out.println(Thread.currentThread().getName() + " i = " + i);
    }
  }
}

二.线程的操作状态

• 1.创建状态 Thread thread = new Thread;
• 2.就绪状态 start();即运行；
• 3.运行状态 run();自动调用该 线程对象 的run()方法，定义了该线程的操作和功能
• 4.堵塞状态 sleep(),wait();
• 5.终止状态 stop(),或run()方法执行完毕。

三.多线程常用方法

sleep

public static void sleep(long millis) throws InterruptedException

• 在指定的毫秒数内让当前正在执行的线程休眠（暂停执行） millis - 以毫秒为单位的休眠时间。

 public static void sleep(long millis, int nanos)throws InterruptedException

• 在指定的毫秒数加指定的纳秒数内让当前正在执行的线程休眠（暂停执行），

join

public final void join() throws InterruptedException

• 等待该线程终止。
• 谁等待谁执行结束呢？
• 当前线程等待 等待在当前线程中调用join方法的 那个线程执行完毕之后，当前线程继续执行

public class Demo2Join {
  public static void main(String[] args) throws InterruptedException {
    Mythread2 mythread3 = new Mythread2();
    for (int i = 0; i < 10; i++) {
      if(i == 0) {
        mythread3.start();
        mythread3.join();
      }
      System.out.println(Thread.currentThread().getName() + "i = " + i);
    }
    //Mythread2 mythread2 = new Mythread2();
  }
}

class Mythread2 extends Thread {
  @Override
  public void run() {
    //调用了该方法
    //对于方法而言，它在哪个线程中被调用，它就运行在哪个线程中
    printNumber();
  }
  private void printNumber() {
    for (int i = 0; i < 100; i++) {
      System.out.println(getName() + " i = " + i);
    }
  }
}

yield

public static void yield()

• 暂停当前正在执行的线程对象，并执行其他线程。
• 严格来说，yield方法，实现的功能是：放弃cpu使用权

setDaemon

public final void setDaemon(boolean on)

• 将该线程标记为守护线程或用户线程。
• 当正在运行的线程都是守护线程时，Java 虚拟机退出(JVM进程自动终止)。
  该方法必须在启动线程前调用。

interrupt

public void interrupt()中断线程。

• 当线程中调用该类的 join()、join(long)、join(long, int)、sleep(long) 或 sleep(long, int)
• 方法过程中受阻，则其中断状态将被清除，它还将收到一个 InterruptedException。

设置或获取线程的名称

 public final String getName()

public final void setName(String name)

返回对当前正在执行的线程对象的引用。

  static Thread currentThread()

java语言中给线程对象设置的优先级，基本没啥用

 public final int getPriority()

 public final void setPriority(int priority)

• 注意事项： 不要试图通脱设置线程的优先级，来控制线程的执行顺序

四.证明一下：JVM多线程的

ublic class Demo1JvmThread {
  public static void main(String[] args) {
    //因为，在我们申请堆内存的同时，jvm中有另外一个线程，在堆内存上，在同时执行垃圾回收的工作
    while (true) {
      int[] intArray = new int[1024];
      intArray = null;
    }
  }
}