线程

一. 线程和进程

1.1 并发与并行

• 并发：指两个或多个事件在同一时间段内发生的。(交替执行)
• 并行：指两个或多个事件在同一时刻发生。(同时执行)

1.2 线程与进程

• 进程：指正在运行中的应用程序，每个进程都有一个独立的内存空间，进程是程序的一次执行过程，是系统运行程序的基本单位。每当用户启动一个进程时，操作系统为该进程分配一个独立的内存空间，让进程在这个独立内存空间运行。
• 线程：线程是进程中的一个执行单元，负责当前进程中程序的执行，一个进程中至少有一个线程。

主线程：

JVM执行main方法，main方法就会进入栈内存，JVM会找操作系统开辟一条main方法通向cpu的执行路径，cup就可以通过这个路径来执行main方法，而这个路径有一个名字，叫(主)线程。

线程调度：

• 分时调度

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

• 抢占式调度

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

1.3 创建线程类

Java使用 java.lang.Thread 类代表线程，所有的线程对象都必须是Thread类或其子类的实例。

Java中通过继承Thread类来创建并启动多线程的步骤如下：

1. 定义Thread类的子类，并重写该类的run()方法，该run()方法的方法体就代表了线程需要完成的任务,因此把run()方法称为线程执行体。

2. 创建Thread子类的实例，即创建了线程对象。

3. 调用线程对象的start()方法来启动该线程。

    public class Demo01 {
	 public static void main(String[] args) {
		//创建自定义线程对象，设置线程名称
		MyThread mt = new MyThread("新的线程！");
		//开启新线程
		mt.start();
		//在主方法中执行for循环
		for (int i = 0; i < 10; i++) {
			System.out.println("main线程！"+i);
		}
	  }
    }

 测试类：

   public class MyThread extends Thread {
	//定义指定线程名称的构造方法
	public MyThread(String name) {
		//调用父类的String参数的构造方法，指定线程的名称
		super(name);
	}
	/**
	 * 重写run方法，线程执行逻辑
	 */
	@Override
	public void run() {
		for (int i = 0; i < 10; i++) {
			System.out.println(getName()+"：正在执行！"+i);
	        }
	 }
    }

二. 多线程

2.1 多线程原理

多线程执行时，在栈内存中，每一个执行线程都有一片自己所属的栈内存空间。进行方法的压栈和弹栈。

当执行线程的任务结束了，线程自动在栈内存中释放了，当所有的执行线程都结束了，进程也就结束了。

2.2 Thread类
构造方法：

public Thread() :分配一个新的线程对象。
public Thread(String name) :分配一个指定名字的新的线程对象。
public Thread(Runnable target) :分配一个带有指定目标新的线程对象。
public Thread(Runnable target,String name) :分配一个带有指定目标新的线程对象并指定名字。

常用方法：

public String getName() :获取当前线程名称。
public void start() :线程开始执行; Java虚拟机调用此线程的run方法。
public void run() :此线程要执行的任务。
public static void sleep(long millis) :使当前正在执行的线程以指定的毫秒数暂停（暂时停止执行）。 
public static Thread currentThread() :返回对当前正在执行的线程对象的引用。

2.3 创建线程第二种方式

第一种方式是继承Thread类，第二种是实现Runnable接口，重写run方法。

实现步骤：

1. 定义Runnable接口的实现类，重写该接口的run方法，定义线程任务。

2. 创建Runnable实现类的对象，并将此对象作为Thread的target来创建Thread对象。该Thread对象才是真正的线程对象。

3. 线程对象调用start方法启动线程，执行run方法。

实现Runnable接口创建多线程程序的好处：

1. 避免了单继承的局限性

一个类只能继承一个类，类继承了Thread类就不能继承其他类

实现Runnbale接口，还可以继承其他的类。

2. 增强了程序的扩展性，降低了程序的耦合性

实现Runnable接口的方式，把设置线程任务和开启线程进行分离。(分藕)

实现类中，重写了run方法：用来设置线程任务，创建Thread类，调用start方法开启线程。

//Runnable接口实现类
public class RunnableImpl implements Runnable{
    //在实现类中重写Runnbale接口的run方法，设置线程任务
    @Override
    public void run() {
        for (int i = 0; i <20 ; i++) {
            System.out.println(Thread.currentThread().getName()+"->"+i);
        }
    }
}

public class Demo01Runnable {
    public static void main(String[] args) {
        //创建一个Runnable接口的实现类对象
        RunnableImpl run = new RunnableImpl();
        //创建Thread类对象，构造方法中传递Runnable接口的实现类对象
        Thread t = new Thread(run);
        //调用Thread类中的start方法，开启新的线程执行run方法
        t.start();
        for (int i = 0; i <20 ; i++) {
            System.out.println(Thread.currentThread().getName()+"-->"+i);
        }
    }
}

2.4 匿名内部类实现线程创建

        //线程的父类是Thread
        //new Thread().start();
        new Thread(){
            //重写run方法，设置线程任务
            @Override
            public void run() {
                for (int i = 0; i <20 ; i++) {
                    System.out.println(Thread.currentThread().getName()+"-->1");
                }
            }
        }.start();

        //线程的接口Runnable
        //Runnable r = new RunnableImpl() 多态
        Runnable r = new Runnable(){
            //重写run方法
            @Override
            public void run() {
                for (int i = 0; i <20 ; i++) {
                    System.out.println(Thread.currentThread().getName()+"-->2");
                }
            }
        };
        new Thread(r).start();