线程的基本概念
很多人会对程序、进程和线程之间理解比较含糊，在此先给出三者的概念：
程序:是一个指令的集合，意思就是我们为了完成特定的功能而编写的代码。
进程:是指程序的一次静态态执行过程, 每个进程都是独立的，且占用特定的地址空间。
线 程: 是进程中一 个 “ 单 一的连续 控 制 流 程 ”，是程序执行流的最小单元，线程又被称为轻量级进程。
进程和线程的区别：
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("线程启动了");
}
}
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);
}
}
}
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);
}
}
}
获取线程基本信息的方法
（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());
}
}
运行结果为：
Thread[main,5,main]
Thread-0
Thread-1
Thread-2
设置线程名称如下：
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());
}
}
判断线程是否处于运行状态
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);
}
}
}
线程的生命周期
当线程被创建以后，它不是一启动（start）就进入运行状态的，也不是一直处于执行状态，执不执行得看cpu有没有调度执行。在线程的生命周期中，它要经过新生（New）、就绪（Runnable）、运行（Running）、阻塞（Blocked）和终止/死亡（Dead）这五种状态。当线程进入运行状态后，它也不是一直“霸占”CPU，一般的操作系统是采用抢占式的方式来让线程获得CPU。所以CPU需要在多条线程之间切换，于是线程状态也会多次在运行、阻塞、就绪之间切换。
