多线程

进程：进程指正在运行的程序。当一个程序进入内存运行，即变成一个进程，进程是处于运行过程中的程序，并且具有一定独立功能。

线程：是进程中的一个执行单元，负责当前进程中程序的执行，一个进程中至少有一个线程。一个线程中是可以有多个线程的，这个应用程序也可以被称为多线程程序。

一个程序运行后至少有一个进程，一个进程中可以包含多个线程

举例：

单线程程序：即，若有多个任务只能依次执行。当上一个任务执行结束后，下一个任务开始执行。

如，去网吧上网，网吧只能让一个人上网，当这个人下机后，下一个人才能上网。

多线程程序：即，若有多个任务可以同时执行。如，去网吧上网，网吧能够让多个人同时上网。

 

    程序运行原理

 

  分时调度

 

所有线程轮流使用 CPU 的使用权，平均分配每个线程占用 CPU 的时间。

 

  抢占式调度

 

优先让优先级高的线程使用 CPU，如果线程的优先级相同，那么会随机选择一个(线程随机性)，Java使用的为抢占式调度。

　　主线程

代码演示：

class Demo{
    String name;
    Demo(String name){
        this.name = name;
    }
    void show()    {
        for (int i=1;i<=10000 ;i++ )        {
            System.out.println("name="+name+",i="+i);
        }
    }
}

class ThreadDemo {
    public static void main(String[] args)     {
        Demo d = new Demo("小强");
         Demo d2 = new Demo("旺财");
        d.show();        
        d2.show();
        System.out.println("Hello World!");
    }
}

jvm启动后，必然有一个执行路径(线程)从main方法开始的，一直执行到main方法结束，这个线程在java中称之为主线程。

Thread类

构造方法：

常用方法：

   创建线程方式一继承Thread类

 代码演示：

public class MyThread extends Thread{
    MyThread(){
        
    }
    public MyThread(String name){
        super(name);
    }
    public void run() {
        System.out.println(super.getName());
        /*for(int j=0;j<10;j++){
            System.out.println("run....."+j);
        }*/
    }

}

测试类：
public class Demo01 {
    // "main"主线程
    public static void main(String[] args) {
        //获取当前执行该方法的线程对象
        Thread m=Thread.currentThread();
        //获取线程对象的名称
        System.out.println(m.getName());
        //System.out.println(0/0);
        //新建一个线程
        MyThread th=new MyThread("蔡文奶");
        //th.setName("蔡文奶");
        //开启线程
        th.start();
        /*for(int i=0;i<10;i++){
            System.out.println("main..."+i);
        }*/
    }

}

线程对象调用 run方法和调用start方法区别？

线程对象调用run方法不开启线程。仅是对象调用方法。线程对象调用start开启线程，并让jvm调用run方法在开启的线程中执行。

 多线程图解：

  获取线程名称

代码演示：

class MyThread extends Thread {  //继承Thread
    MyThread(String name){
        super(name);
    }
    //复写其中的run方法
    public void run(){
        for (int i=1;i<=20 ;i++ ){
            System.out.println(Thread.currentThread().getName()+",i="+i);
        }
    }
}
class ThreadDemo {
    public static void main(String[] args)     {
        //创建两个线程任务
        MyThread d = new MyThread();
        MyThread d2 = new MyThread();
        d.run();//没有开启新线程, 在主线程调用run方法
        d2.start();//开启一个新线程，新线程调用run方法
    }
}

接口中的方法：

 Thread类构造方法

 

代码演示：

public class Demo02 {
    public static void main(String[] args) {
        //创建线程执行目标类对象
        Runnable runn = new MyRunnable();
        //将Runnable接口的子类对象作为参数传递给Thread类的构造函数
        Thread thread = new Thread(runn);
        Thread thread2 = new Thread(runn);
        //开启线程
        thread.start();
        thread2.start();
        for (int i = 0; i < 10; i++) {
            System.out.println("main线程：正在执行！"+i);
        }
    }
}
    自定义线程执行任务类
public class MyRunnable implements Runnable{

    //定义线程要执行的run方法逻辑
    @Override
    public void run() {
        
        for (int i = 0; i < 10; i++) {
            System.out.println("我的线程：正在执行！"+i);
        }
    }
}

      线程的匿名内部类使用

方法一：

public class Demo01 {
    public static void main(String[] args) {
        //匿名内部类
        new Thread(){
            public void run() {
                for(int i=0;i<50;i++){
                    System.out.println("run..."+i);
                }
            }
        }.start();
    }

}

方式2：使用匿名内部类的方式实现Runnable接口，重新Runnable接口中的run方法

public class Demo02 {
    public static void main(String[] args) {
        Runnable run=new Runnable(){
            public void run() {
                for(int i=0;i<50;i++){
                    System.out.println("run..."+i);
                }    
            }
        };
        Thread th=new Thread(run);
        th.start();
        //简化
        new Thread(new Runnable(){
            public void run() {
                for(int i=0;i<50;i++){
                    System.out.println("run..."+i);
                }    
            }
        }).start();
    }

}