1、线程的含义:

   线程是一个进程中的执行场景,一个进程可以启动多个线程。多线程不是为了执行速度,而是为了提高应用程序的使用率,线程和线程共享“堆内存和方法区内存”,栈内存是独立的,一个线程一个栈。

   线程的另一种理解:是程序中的执行线程。Java 虚拟机允许应用程序并发地运行多个执行线程。

2、进程的含义:

  一个进程对应一个应用程序,启动一个应用程序也就启动了一个进程,现在的计算机都是支持多进程操作的,在同一个操作系统中可以同时启动多个进程。多进程的作用不是提高执行速度,而是提高CPU的使用率。进程和进程之间的内存是独立的。

3、java程序的运行原理:

java命令启动java虚拟机,启动jvm等于启动了一个应用程序,表示启动了一个进程。该进程会自动的启动一个“主线程”,然后主线程去调用某个类的main方法,所以main方法运行在主线程中。在此之前的程序都是单线程的,并且我们所有的方法都是在主线程中运行的

运行原理详解

引用:

4、线程的创建和启动:

|方式一:|
A、继承java.lang.Thread类
B、重写run方法
public class Processor extends Thread {
   @Override
   public void run() {
    for(int i=0;i<9;i++){
       System.out.println("Thread---->"+i);
   }
  }
}public class ThreadTest01 {
   public static void main(String[] args) {
    //创建线程
    Thread t=new Processor();
    //启动线程:这段代码执行瞬间结束,就是告诉jvm再分配一个新的栈给t线程,t线程会自动调用run()方法
    t.start();
    /*有了多线程之后,main方法结束,只是主线程栈中没有方法栈帧了,
    但是其他线程或者其他栈中还有栈帧。所以main方法结束程序可能还在运行。
    */
   }
}|方式二:|
A:实现Runnable接口,
B:实现run()方法
public class Processor02 implements Runnable {
   //这种方式是推荐的,因为一个类实现接口之外保留了类的继承
   @Override
   public void run() {
    for(int i=0;i<10;i++){
       System.out.println("run-->"+i);
   }
 }
}public class ThreadTest02 {
   public static void main(String[] args) {
    Thread t=new Thread(new Processor02());
      t.start();
   }
}

5、线程的生命周期

1)五个状态:新建、就绪、运行、阻塞、消亡;

java 查看当前应用运行线程数_java 查看当前应用运行线程数

2)CPU时间片:

  通常计算机只有一个CPU,CPU在某一个时刻只能执行一条指令,线程只有得到CPU时间片,也就是使用权,才可以执行指令,在单CPU的机器上线程不是并行运行的,只有多个CPU上线程上才可以并行运行。

  java虚拟机要负责线程的调度,取得CPU的使用权,目前有两种调度模型:分时调度模型和抢占式调度模型。

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

  线程的优先级主要分为三种:MAX_PRIORITY(最高级);MIN_PRIORITY(最低级);   NORM_PRIORITY(标准)默认
  线程的最高优先级是10,最低优先级是1,默认优先级是5,所以优先级从1到10;

|示例:给线程设置优先级|
public class Processor04 extends Thread {
   @Override
   public void run() {
    for(int i=0;i<10;i++){
       System.out.println(Thread.currentThread().getName()+"--->"+i);
    }
   }
}public class ThreadTest4 {
   public static void main(String[] args) {
      System.out.println(Thread.MAX_PRIORITY);
      System.out.println(Thread.MIN_PRIORITY);
      System.out.println(Thread.NORM_PRIORITY);
  
      Thread thread2=new Processor04();
      thread2.setName("t2");
      thread2.setPriority(3);
  
      Thread thread1=new Processor04();
      System.out.println(thread1.getName());//Thread-0
      thread1.setName("t1");
      System.out.println(thread1.getName());//t1
      System.out.println(thread1.getPriority());//默认的优先级为 5
  
      thread1.setPriority(9);//t1线程先执行
      thread1.start();
      thread2.start();
   }
}|示例:阻塞线程|
public class Processor05 extends Thread {
   public void run(){
    for(int i=0;i<10;i++){
       System.out.println(Thread.currentThread().getName()+"-->"+i);
      try {
          Thread.sleep(1000);
       } catch (InterruptedException e) {
       // TODO Auto-generated catch block
              e.printStackTrace();
    }
  }
   try {
       m1();
    } catch (Exception e) {
       // TODO Auto-generated catch block
       e.printStackTrace();
    }
  
   }
 public static void m1() throws Exception{
 }
}|示例:终止线程的|
public class Processor06 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) {
           // TODO Auto-generated catch block
           e.printStackTrace();
        }
      }else{
        return;
      }
   System.out.println(Thread.currentThread().getName()+"-->"+i);
    }
   }
}public class ThreadTest06 {
   public static void main(String[] args) {
      Processor06 pro=new Processor06();
      Thread thread=new Thread(pro);
      thread.setName("t");
      thread.start();
      //用户指定多长时间后后线程终止:
      try {
         Thread.sleep(5000);//用户指定5秒后
      } catch (InterruptedException e) {
         // TODO Auto-generated catch block
         e.printStackTrace();
      }
        //在5秒钟之后通过run=false使得run方法不再执行,从而终止线程
        pro.run=false;//线程终止
     }
}|示例:Thread类中的yield方法|
Thread类中有一个yield方法它与sleep()类相似,只是不能由用户指定暂停多长时间,并且yield()方法只能让同优先级的线程有执行的机会
public class Processor07 extends Thread {
   /*
   Thread.yield();
   1.该方法是一个静态方法
   2.作用:给同一个优先级别的线程让位,但是让位时间不固定
   3.和sleep方法相同,就是yield时间不固定
   */
   @Override
   public void run() {
    for(int i=0;i<1000;i++){
       System.out.println(Thread.currentThread().getName()+"-->"+i);
      if(i%20==0){
          Thread.yield();
    }
  }
 }
}public class ThreadTest07 {
   public static void main(String[] args) {
    Thread thread=new Processor07();
    thread.setName("t1");
    thread.start();
    for(int i=0;i<500;i++){
       System.out.println(Thread.currentThread().getName()+"-->"+i);
    }
   }
}|Thread中的join()方法使用:|
t线程去调用了join方法,调用后main线程将被阻塞不执行,直到t线程执行完毕,main线程才会执行;
public class Processor08 implements Runnable {
   @Override
   public void run() {
    for(int i=0;i<10;i++){
      try{
         Thread.sleep(100);
         System.out.println(Thread.currentThread().getName()+"-->"+i);
     
      }catch(InterruptedException e){
    }
   }
 }
}public class ThreadTest08 {
   public static void main(String[] args) {
      Thread thread=new Thread(new Processor08());
      thread.setName("t");
      thread.setPriority(10);
      thread.start();
      try {
         thread.join();//表示将t线程合并到主线程中,也就意味着两个栈空间变成了一个栈空间,
      } catch (InterruptedException e) {
         // TODO Auto-generated catch block
         e.printStackTrace();
      }
      //主线程
      for(int i=0;i<50;i++){
         System.out.println(Thread.currentThread().getName()+"-->"+i);
    }
 }
}

5、jvm

1) 什么是JVM?
2) JRE/JDK/JVM是什么关系?
3) JVM原理
4)JVM执行程序的过程
5)JVM的生命周期
6)JVM的体系结构
7)JVM运行时数据区

引用:

 

细水长流,打磨濡染,渐趋极致,才是一个人最好的状态。