java之多线程

1、什么是进程？

一个进程代表一个应用程序

2、多进程有什么作用？

单进程计算机只能做一件事情。

多进程不是提高运行速度，而是体高CPU的使用率

进程和进程的内存是独立的

3、什么是线程

线程是一个进程中的执行场景。一个进程可以启动多个线程

4、多线程有什么作用

多线程不是为了提高执行速度，而是提高应用程序的使用率

线程和线程共享“堆内存和方法区内存”,栈内存是独立的，一个线程一个栈

5、java程序的运行原理

java命令会启动java虚拟机，启动JVM,等同于启动了一个应用程序，表示启动了一个

进程，该进程会自动启动一个主线程，然后主线程去调用某个类中的main方法，所以

main方法运行在主线程中，在此之前所有程序都是单线程的

举个栗子：

分析一下程序有几个线程？

class Test {
    public static void main(String[] args){
        m1();
    }
    public static void m1() {
        m2();
    }
    public static void m2() {
        m3();
    }
    public static void m3() {
        System.out.println("m3....");
    }
}

java中多线程的实现方式

在java语言中实现多线程的第一种方法：

step1、继承java.lang.Thread

step2、重写run方法

如何定义线程？
如何创建线程？
如何启动线程？

举个栗子：

class Test {
    public static void main(String[] args){
        
        //创建线程
        Thread t = new Processor();
        // 启动线程
        t.start(); // 这段代码执行瞬间结束，告诉JVM再分配一个新的栈给t线程
                   // run方法不需要程序员手动调用，系统线程启动之后自动调用run方法
        
        // 这段线程在主线程中运行
        for(int i = 0; i < 10;i++) {
            System.out.println("main -- > " + i);
        }
        // 有了多线程之厚，main方法结束只是主线程栈中没有方法栈帧了
        // 但是其他线程或者其他栈中还有栈帧
        // main方法结束，程序可能还在运行
    }
}
// 定义一个线程
class Processor extends Thread{
    // 重写run方法
    public void run() {
        for(int i = 0;i < 10; i++) {
            System.out.println("run -- > " + i);
        }
    }
}

解释如图：

JVM

java中实现线程的第二种方式：

step1、写一个类实现java.lang.Runnable接口

step2、实现run方法

class Test {
    public static void main(String[] args){
        
        //创建线程
        Thread t = new Thread(new Processor());
        // 启动线程
        t.start(); // 这段代码执行瞬间结束，告诉JVM再分配一个新的栈给t线程
                   // run方法不需要程序员手动调用，系统线程启动之后自动调用run方法
        
        // 这段线程在主线程中运行
        for(int i = 0; i < 10;i++) {
            System.out.println("main -- > " + i);
        }
    }
}
// 这种方式是推荐的，因为一个类实现接口之外保留了类的继承
class Processor implements Runnable{
    // 重写run方法
    public void run() {
        for(int i = 0;i < 10; i++) {
            System.out.println("run -- > " + i);
        }
    }
}

线程生命周期如下图：

优先级分类：最高级、标准级、最低级

优先级高的获取cpu时间片相对多一些
优先级：1-10
最低 1
最高 10
默认 5

class Test {
    public static void main(String[] args){
        
        System.out.println(Thread.MAX_PRIORITY); // 10
        System.out.println(Thread.MIN_PRIORITY); // 1
        System.out.println(Thread.NORM_PRIORITY); // 5
        
        Thread t1 = new Processor();
        t1.setName("t1");
        
        Thread t2 = new Processor();
        t1.setName("t2");
        
        System.out.println(t1.getPriority()); // 5
        System.out.println(t2.getPriority()); // 5
        // 获取优先级
        t1.setPriority(5);
        t2.setPriority(10);
        // 设置优先级
        t1.start();
        t2.start();
        
    }
}
// 这种方式是推荐的，因为一个类实现接口之外保留了类的继承
class Processor extends Thread{
    // 重写run方法
    public void run() {
        for(int i = 0;i < 10;i++) {
            System.out.println(Thread.currentThread().getName() + "-->" + i);
        }
    }
}

class Test {
    public static void main(String[] args){
        // 如何获得当前线程对象
        Thread t = Thread.currentThread(); // t保存内存地址指向的线程是”主线程对象“
        
        // 获取线程的名字
        System.out.println(t.getName()); // main
        
        Thread t1 = new Thread(new Processor());
        t1.start();
        
        Thread t2 = new Thread(new Processor());
        t2.setName("hl"); // 改名
        t2.start();
    }
}
// 这种方式是推荐的，因为一个类实现接口之外保留了类的继承
class Processor extends Thread{
    // 重写run方法
    public void run() {
        Thread t = Thread.currentThread(); // t保存的内存地址指向的线程是t1线程对象
        System.out.println(t.getName()); // Thread-0
    }
}

三个方法:

1、获取当前线程对象 Thread.currentThread();

2、给线程起名字 t.setName();

3、获取线程的名字 t.getName();

class Test {
    public static void main(String[] args){
        // 如何获得当前线程对象
        Thread t = Thread.currentThread(); // t保存内存地址指向的线程是”主线程对象“      
        Thread t1 = new Thread(new Processor());
        t1.start();
        
    }
}
// 这种方式是推荐的，因为一个类实现接口之外保留了类的继承
class Processor extends Thread{
    // 重写run方法
    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();
            }
        }
    }
}

一道面试题：

问下列程序是否发生堵塞

class Test {
    public static void main(String[] args){
        
        // 创建线程
        Thread t = new Processor();
        t.setName("t");
        
        t.start();// 启动线程
        
        //休眠
        try {
            t.sleep(5000);
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } // 等同于Thread.sleep(5000);堵塞的是当前线程，和t线程无关
        
        System.out.println("Hello world!");
    }
}
// 这种方式是推荐的，因为一个类实现接口之外保留了类的继承
class Processor extends Thread{
    public void run() {
        for(int i = 0; i < 10; i++) {
            System.out.println(Thread.currentThread().getName() + "---->" + i);
        }
    }
}

1、Thread.sleep(毫秒)
2、sleep方法是一个静态方法
3、该方法的作用，阻塞当前线程，腾出cpu，让给其它线程

class Test {
    public static void main(String[] args){
        
        // 创建线程
        Thread t = new Processor();
        t.setName("t");
        
        t.start();// 启动线程
        
        //休眠
        try {
            t.sleep(5000);
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } // 等同于Thread.sleep(5000);堵塞的是当前线程，和t线程无关
        
        System.out.println("Hello world!");
    }
}
// 这种方式是推荐的，因为一个类实现接口之外保留了类的继承
class Processor extends Thread{
    public void run() {
        for(int i = 0; i < 10; i++) {
            System.out.println(Thread.currentThread().getName() + "---->" + i);
        }
    }
}