【Java学习】多线程

并发：两个或多个事件在同一时间段内发生
并行：两个或多个事件在同一时刻发生(同时发生)

进程：是指一个内存中运行的应用程序，每个进程都有一个独立的内存空间，一个应用程序可以同时运行多个进程；进程也是程序的一次执行过程，是系统运行程序的基本单位；系统运行一个程序即是一个进程从创建、运行到消亡的过程。
线程：线程是进程中的一个执行单元，负责当前进程中程序的执行，一个进程至少有一个线程。一个进程中是可以有多个线程的，这个应用程序也可以称之为多线程程序

线程调度：

• 分时调度：所有线程轮流使用CPU的使用权，平均分配每个线程占用CPU的时间
• 抢占式调度：抢先让优先级高的线程使用CPU，如果线程的优先级相同，那么会随机选择一个(线程随机性)，Java使用的为抢占式调度

创建多线程程序的第一张方式：创建Thread的子类

实现步骤：
1.创建一个Thread类的子类
2.在Thread类的子类中重写Thread中的run方法，设置线程任务
3.创建Thread类的子类对象
4.调用Thread类中的方法start方法，开启新的线程饿，执行run方法
void start() 使该线程开始执行；java虚拟机调用该线程的run方法
结果是两个线程并发的运行；当前线程和另一个线程
多次启动一个线程是非法的。特别是当线程已经结束执行后，不能再重新启动
java程序属于抢占式调度，那个线程的优先级高，那个线程优先执行；同一个优先级，随机选择一个执行

主线程：执行主方法的线程

单线程程序：java程序中只有一个线程
执行从main方法开始，从上而下依次执行

Thread中常用的方法：

获取线程的名称：
1.使用Thread类中的方法getName()
String getName() 返回该线程的名称。
2.可以先获取到当前正在执行的线程，使用线程中的方法getName()获取线程的名称
static Thread currentThread() 返回对当前正在执行的线程对象的引用

public static void sleep(long millis):使当前正在执行的线程以指定的毫秒数暂停
毫秒结束之后，线程继续执行

public class Demo01Sleep {
    public static void main(String[] args) {
        for (int i = 0; i < 60; i++) {
            System.out.println(i);

            try{
                Thread.sleep(1000);

            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

    }
}

创建多线程程序的第二种方式：实现Runnable接口
Runnable 接口应该由那些打算通过某一线程执行其实例的类来实现。类必须定义一个称为run的无参数方法。
Thread类的构造方法
Thread(Runnable target) 分配新的Thread对象
Thread(Runnable target,String name) 分配新的Thread对象
实现步骤：
1.创建一个Runnable接口的实现类
2.在实现类中重写Runnable接口的run方法，设置线程任务
3.创建一个Runnable接口的实现类对象
4.创建Thread类对象，构造方法中传递Runnable接口的实现类对象
5.调用Thread类中的start方法，开启新的线程执行run方法

public class Demo01Runnable {
    public static void main(String[] args) {
        Runnable run = new RunnableImpl();
        Thread t = new Thread(run);
        t.start();


        for (int i = 0; i < 20; i++) {
            System.out.println(Thread.currentThread().getName() + "-->" + i);
        }
    }
}

public class RunnableImpl implements Runnable {
    @Override
    public void run() {
        for (int i = 0; i < 20; i++) {
            System.out.println(Thread.currentThread().getName() + "-->" + i);
        }
    }
}

实现Runnable接口创建多线程程序的好处：
1.避免了单继承的局限性
一个类只能继承一个类，类继承了Thread类就不能继承其他的类
实现了Runnable接口，还可以继承其他的类，实现其他的接口
2.增强了程序的扩展性，降低了程序的耦合性
实现Runnable接口的方式，把设置线程任务和开启新线程进行了分离
创建Thread类对象，调用start方法：用来开启新线程

匿名内部类方式实现线程的创建

匿名：没有名字
内部类：写在其他类内部的类

匿名内部类作用：简化代码
把子类继承父类，重写父类的方法，创建子类对象合一步完成
把实现类实现类接口，重写接口中的方法，创建实现类对象合成一步完成
匿名内部类的最终产物：子类/实现类对象，而这个类没有名字

格式：
new 父类/接口(){
重写父类/接口中的方法
}

public class Demo02InnerClassThread {
    public static void main(String[] args) {

        new Thread(){
            //重写run方法，设置线程任务
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName() + "da");
            }
        }.start();

        Runnable r = new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < 10; i++) {
                    System.out.println(Thread.currentThread().getName()+ "ha");
                }
            }
        };
        new Thread(r).start();
    }

}