JVM原理

JVM原理

https://blog.csdn.net/xiangzhihong8/article/details/80412795

Java多线程

https://www.cnblogs.com/java1024/archive/2019/11/28/11950129.html

Java中线程实现的方式

在 Java 中实现多线程有两种手段，一种是继承 Thread 类，另一种就是实现 Runnable 接口。下面我们就分别来介绍这两种方式的使用。

实现 Runnable 接口

class MyThread implements Runnable{ // 实现Runnable接口，作为线程的实现类 
    private String name ;       // 表示线程的名称 
    public MyThread(String name){ 
        this.name = name ;      // 通过构造方法配置name属性 
    } 
    public void run(){  // 覆写run()方法，作为线程 的操作主体 
        for(int i=0;i<10;i++){ 
            System.out.println(name + "运行，i = " + i) ; 
        } 
    } 
}; 
public class RunnableDemo01{ 
    public static void main(String args[]){ 
        MyThread mt1 = new MyThread("线程A ") ;    // 实例化对象 
        MyThread mt2 = new MyThread("线程B ") ;    // 实例化对象 
        Thread t1 = new Thread(mt1) ;       // 实例化Thread类对象 
        Thread t2 = new Thread(mt2) ;       // 实例化Thread类对象 
        t1.start() ;    // 启动多线程 
        t2.start() ;    // 启动多线程 
    } 
};

运行结果

继承 Thread 类

class MyThread extends Thread{  // 继承Thread类，作为线程的实现类 
    private String name ;       // 表示线程的名称 
    public MyThread(String name){ 
        this.name = name ;      // 通过构造方法配置name属性 
    } 
    public void run(){  // 覆写run()方法，作为线程 的操作主体 
        for(int i=0;i<10;i++){ 
            System.out.println(name + "运行，i = " + i) ; 
        } 
    } 
}; 
public class ThreadDemo02{ 
    public static void main(String args[]){ 
        MyThread mt1 = new MyThread("线程A ") ;    // 实例化对象 
        MyThread mt2 = new MyThread("线程B ") ;    // 实例化对象 
        mt1.start() ;   // 调用线程主体 
        mt2.start() ;   // 调用线程主体 
    } 
};

运行结果

从程序可以看出，现在的两个线程对象是交错运行的，哪个线程对象抢到了 CPU 资源，哪个线程就可以运行，所以程序每次的运行结果肯定是不一样的，在线程启动虽然调用的是 start() 方法，但实际上调用的却是 run() 方法定义的主体。

Thread 类和 Runnable 接口

通过 Thread 类和 Runable 接口都可以实现多线程，那么两者有哪些联系和区别呢？下面我们观察 Thread 类的定义。

public class Thread extends Object implements Runnable

从 Thread 类的定义可以清楚的发现，Thread 类也是 Runnable 接口的子类，但在Thread类中并没有完全实现 Runnable 接口中的 run() 方法，下面是 Thread 类的部分定义。

  Private Runnable target； 
 public Thread(Runnable target,String name){ 
      init(null,target,name,0); 
  } 
  private void init(ThreadGroup g,Runnable target,String name,long stackSize){ 
      ... 
      this.target=target; 
  } 
  public void run(){ 
     if(target!=null){ 
         target.run(); 
     } 
 }

从定义中可以发现，在 Thread 类中的 run() 方法调用的是 Runnable 接口中的 run() 方法，也就是说此方法是由 Runnable 子类完成的，所以如果要通过继承 Thread 类实现多线程，则必须覆写 run()。

实际上 Thread 类和 Runnable 接口之间在使用上也是有区别的，如果一个类继承 Thread类，则不适合于多个线程共享资源，而实现了 Runnable 接口，就可以方便的实现资源的共享。

线程的状态变化

要想实现多线程，必须在主线程中创建新的线程对象。任何线程一般具有5种状态，即创建，就绪，运行，阻塞，终止。下面分别介绍一下这几种状态：

• 创建状态

在程序中用构造方法创建了一个线程对象后，新的线程对象便处于新建状态，此时它已经有了相应的内存空间和其他资源，但还处于不可运行状态。新建一个线程对象可采用Thread 类的构造方法来实现，例如 “Thread thread=new Thread()”。

• 就绪状态

新建线程对象后，调用该线程的 start() 方法就可以启动线程。当线程启动时，线程进入就绪状态。此时，线程将进入线程队列排队，等待 CPU 服务，这表明它已经具备了运行条件。

• 运行状态

当就绪状态被调用并获得处理器资源时，线程就进入了运行状态。此时，自动调用该线程对象的 run() 方法。run() 方法定义该线程的操作和功能。

• 阻塞状态

一个正在执行的线程在某些特殊情况下，如被人为挂起或需要执行耗时的输入/输出操作，会让 CPU 暂时中止自己的执行，进入阻塞状态。在可执行状态下，如果调用sleep(),suspend(),wait() 等方法，线程都将进入阻塞状态，发生阻塞时线程不能进入排队队列，只有当引起阻塞的原因被消除后，线程才可以转入就绪状态。

• 死亡状态

线程调用 stop() 方法时或 run() 方法执行结束后，即处于死亡状态。处于死亡状态的线程不具有继续运行的能力。

在此提出一个问题，Java 程序每次运行至少启动几个线程？

回答：至少启动两个线程，每当使用 Java 命令执行一个类时，实际上都会启动一个 JVM，每一个JVM实际上就是在操作系统中启动一个线程，Java 本身具备了垃圾的收集机制。所以在 Java 运行时至少会启动两个线程，一个是 main 线程，另外一个是垃圾收集线程。

取得和设置线程的名称

class MyThread implements Runnable{ //实现Runnable接口 
    public void run(){ 
       for(int i=0;i<3;i++){ 
           System.Out.Println(Thread.currentThread().getName()+"运行, i="+i);  //取得当前线程的名称 
       } 
  } 
}; 

public class ThreadDemo{ 
public static void main(String args[]){ 
    MyThread my=new MyThread();  //定义Runnable子类对象 
    new Thread(my).start;    //系统自动设置线程名称 
    new Thread(my,"线程A").start();  //手工设置线程名称 
  } 
};

运行结果

线程的操作方法

刚才在分析自定义模式工作原理的时候其实就已经提到了，如果想要更改Glide的默认配

线程的强制运行

在线程操作中，可以使用 join() 方法让一个线程强制运行，线程强制运行期间，其他线程无法运行，必须等待此线程完成之后才可以继续执行。

class MyThread implements Runnable{ // 实现Runnable接口 
    public void run(){  // 覆写run()方法 
        for(int i=0;i<50;i++){ 
            System.out.println(Thread.currentThread().getName() 
                    + "运行，i = " + i) ;  // 取得当前线程的名字 
        } 
    } 
}; 
public class ThreadJoinDemo{ 
    public static void main(String args[]){ 
        MyThread mt = new MyThread() ;  // 实例化Runnable子类对象 
        Thread t = new Thread(mt,"线程");     // 实例化Thread对象 
        t.start() ; // 启动线程 
        for(int i=0;i<50;i++){ 
            if(i>10){ 
                try{ 
                    t.join() ;  // 线程强制运行 
                }catch(InterruptedException e){
                } 
            } 
            System.out.println("Main线程运行 --> " + i) ; 
        } 
    } 
};

Java死锁

https://www.cnblogs.com/java1024/archive/2019/11/28/11950129.html

多线程可能导致多个线程对一个资源操作时出现资源同步（例如 银行卡里只有200 而两人同时对该卡进行消费操作，把卡里的钱花成负数）>声明同步方法解决资源被占问题>过多的同步也可能带来死锁（例如，现在张三想要李四的画，李四想要张三的书，张三对李四说“把你的画给我，我就给你书”，李四也对张三说“把你的书给我，我就给你画”两个人互相等对方先行动，就这么干等没有结果，这实际上就是死锁的概念。）所谓死锁，就是两个线程都在等待对方先完成，造成程序的停滞，一般程序的死锁都是在程序运行时出现的。

同步以及死锁

一个多线程的程序如果是通过 Runnable 接口实现的，则意味着类中的属性被多个线程共享，那么这样就会造成一种问题，如果这多个线程要操作同一个资源时就有可能出现资源同步问题。

解决方法：

同步代码块

synchronized(同步对象)｛ 
 需要同步的代码 
｝

class MyThread implements Runnable{ 
    private int ticket = 5 ;    // 假设一共有5张票 没有同步的操作的话会把票卖到负数
    public void run(){ 
        for(int i=0;i<100;i++){ 
            synchronized(this){ // 要对当前对象进行同步 
                if(ticket>0){   // 还有票 
                    try{ 
                        Thread.sleep(300) ; // 加入延迟 
                    }catch(InterruptedException e){ 
                        e.printStackTrace() ; 
                    } 
                    System.out.println("卖票：ticket = " + ticket-- ); 
                } 
            } 
        } 
    } 
}; 
public class SyncDemo02{ 
    public static void main(String args[]){ 
        MyThread mt = new MyThread() ;  // 定义线程对象 
        Thread t1 = new Thread(mt) ;    // 定义Thread对象 
        Thread t2 = new Thread(mt) ;    // 定义Thread对象 
        Thread t3 = new Thread(mt) ;    // 定义Thread对象 
        t1.start() ; 
        t2.start() ; 
        t3.start() ; 
    } 
};