Java线程全解

并发和并行
并发：指两个或者多个事件在同一个时间段内发生。
并行：指两个或多个事件在同一个时刻发生（同时发生）。
进程和线程
进程就相当于电脑有运行内存和硬盘内存，下载一个软件会被储存在硬盘中，而点击这个软件之后开始运行就会占用运行内存的空间

线程就相当于软件中的功能，当点击软件中的功能时，便会通过线程进入cpu,然后cpu就会切换实现这些功能。

主线程：执行主（main）方法的程序

单线程程序:
java程序中只有一个线程
执行从main方法开始，从上到下依次执行
JVM执行main方法，main方法会进入到栈内存

下面就是一个单线程程序

public class Demo01MainThread {
    public static void main(String[] args) {
        Person p1 = new Person("小强");
        p1.run();

        Person p2 = new Person("旺财");
        p2.run();
    }
}

public class Person {
    private String name;

    public void run(){
        //定义循环，执行20次
        for (int i = 0; i < 20; i++) {
            System.out.println(name+"--->"+i);
        }
    }

    public Person() {
    }

    public Person(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}

图解

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

//定义一个Thread类的子类
public class MyThread extends Thread {
    //重写Thread类中的run方法，设置线程任务

    @Override
    public void run() {
        //获取线程名称
      //  String name = getName();
      //  System.out.println(name);

        Thread t = Thread.currentThread();
        System.out.println(t);//Thread[Thread-0,5,main]

        String name = t.getName();
        System.out.println(name);
    }
}

/*
*   线程名称：
*       主线程：main
*       新线程：Thread-0，Thread-1，Thread-2
* */
public class Demo20MyThread {
    public static void main(String[] args) {
        //创建Thread类的子类对象
        MyThread mt = new MyThread();
        //调用start方法，开启新线程，执行run方法
        mt.start();

        new MyThread().start();
        new MyThread().start();

    }
}

创建多线程程序的第二种方式：实现Runnable接口

Runnable 接口应该由那些打算通过某一线程执行其实例的类来实现。类必须定义一个称为 run 的无参数方法。

    Thread()
              分配新的 Thread 对象。
    Thread(Runnable target)
              分配新的 Thread 对象。

实现步骤：
1.创建一个Runnable接口实现类
2.在实现类中重写Runnable接口的run方法，设置线程任务
3.创建一个Runnable接口的实现类对象
4.创建Thread类对象，构造方法中传递Runnable接口的实现类对象
5.调用Thread类中的start方法，开启新的线程执行run方法

public class Demo22Runnable {
    public static void main(String[] args) {
        //3.创建一个Runnable接口的实现类对象
        RunnableImpl run = new RunnableImpl();
        //4.创建Thread类对象，构造方法中传递Runnable接口的实现类对象
        Thread t = new Thread(run);
        //5.调用Thread类中的start方法，开启新的线程执行run方法
        t.start();

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

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

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

1.避免了单继承的局限性
一个类只能继承一个类，类继承了Thread类就不能继承其他的类
实现了Runnable接口，还可以继承其他的类，实现其他都接口

2.增强了程序的扩展性，降低了程序的耦合性（解耦） 实现Runnable接口的方式，把设置线程任务和开启新线程进行了分离（解耦） 实现类中， 重写了run方法：用来设置线程任务 创建Thread类对象，调用start方法：用来开启新的线程