**线程的基本概念和线程的使用方法浓缩版**

线程的基本概念

很多人会对程序、进程和线程之间理解比较含糊，在此先给出三者的概念： 程序:是一个指令的集合，意思就是我们为了完成特定的功能而编写的代码。 进程:是指程序的一次静态态执行过程, 每个进程都是独立的，且占用特定的地址空间。 线 程: 是进程中一 个 “ 单 一的连续 控 制 流 程 ”，是程序执行流的最小单元，线程又被称为轻量级进程。

进程和线程的区别： 1、进程是资源分配的基本单位，线程是程序执行的基本单位和任务调度的基本单位。 2、进程有自己的独立地址空间，每启动一个进程，系统就会为它分配地址空间，进程间的切换开销大。而线程是共享进程中的数据的，使用相同的地址空间，因此CPU切换一个线程的花费远比进程要小很多。 3、线程之间的通信更方便，同一进程下的线程共享全局变量、静态变量等数据，而进程之间的通信需要以通信的方式（IPC)进行。 4、在操作系统中能同时运行多个进程（程序）；而在同一个进程（程序）中有多个线程同时执行（通过CPU调度，在每个时间片中只有一个线程执行） 5.没有线程的进程可以看做是单线程的，如果一个进程内有多个线程，则执行过程不是一条路线，而是多条路线（线程）共同完成的；线程是进程的一部分，所以线程也被称为轻权进程或者轻量级进程。

线程的使用

可以用两种方式来实现多线程 1.通过继承Thread类来实现，步骤如下： （1）继承Thread类 （2）重写run()方法 （3）通过start()方法启动线程 此方式的缺点：java中的类是单继承，一旦继承了Thread类就不能再去继承其他类了。

public class MyTest {
    public static void main(String[] args) {
        MyThread myThread = new MyThread();
        myThread.start();//启动线程
    }
}
//继承Thread类
class MyThread extends Thread{
    @Override
//    重写run方法
    public void run() {
        System.out.println("线程启动了");
    }
}
1234567891011121314

2.通过实现接口Runnable实现多线程，步骤如下： （1）编写类来实现Runnable接口 （2）实现run()方法 （3）通过Thread类的start()方法启动线程

//具备了多线程操作的能力
public class MyRunnable  implements Runnable{
    @Override
    public void run() {
        for(int i=0;i<10;i++){
            System.out.println("MyRunnable.run()---->"+i);
        }
    }
​
}
​
1234567891011
public class Test1 {
    public static void main(String[] args) {
        //创建线程类的对象
        MyRunnable my=new MyRunnable();
        //start()方法是Thread类中的方法
        Thread t=new Thread(my);
        t.start();//启动线程
        
        //主线程中的循环
        for(int i=0;i<10;i++){
            System.out.println("Test1.main()---------->"+i);
        }
    }
}
​
123456789101112131415

获取线程基本信息的方法 （1）static Thread currentThread()：返回当前执行的线程 （2）final String getName()：返回线程的名称 （3）final boolean isAlive()：判断线程是否处于运行状态

获取线程名称如下所示：

public class TestThreadMethod {
    public static void main(String[] args) {
        Thread t = Thread.currentThread();
        //toString()方法得到的内容 为 [线程名称,线程的优先级,线程组的名称]
        System.out.println(t.toString());
        MyThread1 my1 = new MyThread1();
        MyThread1 my2 = new MyThread1();
        MyThread1 my3 = new MyThread1();
        my1.start();
        my2.start();
        my3.start();
​
        /**在Thread类中一定有一个静态变量int，用于统计创建线程的个数 */
        //线程的默认的命名规则  Thread - int类型的变量的值
    }
}
class MyThread1 extends Thread{
    @Override
    public void run() {
        Thread t = Thread.currentThread();
        System.out.println("线程名称:"+t.getName());
    }
}
1234567891011121314151617181920212223

运行结果为：

Thread[main,5,main]
Thread-0
Thread-1
Thread-2
1234

设置线程名称如下：

public class TestSetName {
    public static void main(String[] args) {
        ThreadSetName ts = new ThreadSetName();
        //可以通过Thread构造方法自定义线程名称
        Thread th = new Thread(ts,"我的线程");
        th.start();
    }
}
class ThreadSetName implements Runnable{
​
    @Override
    public void run() {
        //获取当前线程对象
        Thread t = Thread.currentThread();
        //打印初始线程名称
        System.out.println("初始线程名称："+t.getName());
        //重新设置线程名称
        t.setName("我的线程new");
        //打印修改后线程名称
        System.out.println("修改后线程名称："+t.getName());
        
    }
}
1234567891011121314151617181920212223

判断线程是否处于运行状态

public class TestIsAlive {
    public static void main(String[] args) {
        //主线程
        MyThread my=new MyThread();
        System.out.println("线程my处于新生状态的是否处于活动状态:"+my.isAlive());
        my.start();//启动线程
        System.out.println("线程my处于就绪状态的线程是否处于活动状态:"+my.isAlive());
        //主线程中的循环
        for(int i=0;i<10;i++){
            System.out.println("----------"+Thread.currentThread().getName()+"--------->"+i);
        }
        //主线程中的最后一句代码
        System.out.println("my线程是否处于活动状态:"+my.isAlive());
    }
}
class MyThread extends Thread{
    @Override
    public void run() {
        for(int i=0;i<10;i++){
            System.out.println(Thread.currentThread().getName()+"---------->"+i);
        }
    }
}
1234567891011121314151617181920212223

线程的生命周期

当线程被创建以后，它不是一启动（start）就进入运行状态的，也不是一直处于执行状态，执不执行得看cpu有没有调度执行。在线程的生命周期中，它要经过新生（New）、就绪（Runnable）、运行（Running）、阻塞（Blocked）和终止/死亡（Dead）这五种状态。当线程进入运行状态后，它也不是一直“霸占”CPU，一般的操作系统是采用抢占式的方式来让线程获得CPU。所以CPU需要在多条线程之间切换，于是线程状态也会多次在运行、阻塞、就绪之间切换。