·什么是线程

线程：进程中负责程序执行的执行单元。一个进程中至少有一个线程。

多线程：一个进程中包含有多个线程，但CPU在同一时间只允许一个线程的进行。所以有多个线程的运行是根据CPU切换完成，如何切换由CPU决定，因此多线程运行具有不确定性。

·线程的创建方法

1.继承Thread类

即创建一个thread类，或者创建一个thread子类的对象

1>Thread类的介绍

Thread类是一个线程类，位于java.lang包下

Thread的主要构造方法：

1.1 thread() 创建一个线程对象

1.2 thread(String name) 创建一个具有指定名称的线程对象

1.3 thread(Runnable target) 创建一个基于runnable接口实现类的线程对象

1.4 thread(Runnable target,string name) 创建一个基于Runnable接口实现类，并且具有指定名称的线程对象

常用方法：

1.1 public void run() 线程相关的代码写在该方法中，一般需要重写

1.2 public void start() 启动线程

1.3 public static void sleep(long m) 线程休眠m毫秒

1.4 public final void join() 优先执行调用join方法的线程

2>具体的代码实现

package _Thread;

class mythread extends Thread{

//重写Run方法

public void run() {

System.out.println(getName()+"线程");

}

}

public class _threadTest {

public static void main(String[] args) {

mythread sr=new mythread();

sr.start;//启动线程

}

}

复制代码

实现结果

然后为了将CPU时间片的轮转体现出来，将加入2个循环如下：

package _Thread;

class mythread extends Thread{

public void run() {

for(int i=1;i<=10;i++)

System.out.println(getName()+"线程"+i+"次");

}

}

public class _threadTest {

public static void main(String[] args) {

mythread sr=new mythread();

sr.start();

for(int i=1;i<=10;i++)

System.out.println("主线程"+i+"次");

}

}

复制代码

两次不同的运行结果：

这说明线程的运行是有cpu随机切换完成的，具有不确定性。

tips:

线程只能启动一次

主方法也是一个线程

2.实现Runnable接口

1>Runnable类的介绍

由于JAVA是不支持多继承的，所以如果一个类已经有一个父类，那么我们就无法通过继承Threadl类来创建线程，此时我们就可以通过实现Runnable接口来完成。Runnable是java中实现线程的接口，它有且只有一个方法Run(),并且任何实现线程功能的类必须实现该接口。

2>具体的代码实现

package _Thread;

class mythread implements Runnable{

public void run() {

System.out.println(Thread.currentThread().getName()+"线程");

/*

由于这里没有继承Thread类中的方法，

所以这里调用Thread中的currentThread()的getName()来获取当前线程的名字

*/

}

}

public class _threadTest {

public static void main(String[] args) {

mythread sr=new mythread();

Thread pr=new Thread(sr);//通过调用Thread类中的含参构造方法来创建一个线程对象

pr.start();

}

}

复制代码

tips：一个实例可以被多个线程所共享，一般用于多个线程处理同一个资源的情况。

·线程的状态和生命周期

1.线程的几种状态

1.1新建(NEW)状态

复制代码

当程序使用new关键字创建了一个线程之后，该线程就处于新建状态.

1.2可运行(Runnable)状态

复制代码

该状态的线程位于可运行线程池中，等待被线程调度选中，获取cpu 的使用权 。

·关于直接调用run()方法

如果直接调用线程对象的run方法，也就是相当于启动线程，并直接执行run方法，而且再run方法结束之前无法运行其他线程。

1.3正在运行(Runnming)状态

复制代码

当CPU开始调度处于可运行状态的线程时，此时线程获得了CPU的时间片才得以真正开始执行run()方法的线程执行体，则该线程处于可运行状态。

1.4阻塞(Blocked)状态

复制代码

处于运行状态的线程在某些情况下，让出CPU并暂时停止该线程的运行，也就是进入了阻塞状态。

1.5终止(Dead)状态

复制代码

线程的run()或call()方法执行完成，线程会正常结束；

线程抛出了一个未捕获的Exception或Errorl异常，线程会意外终止；

或者直接调用该线程stop()方法来结束该线程，但可能会导致线程的死锁；

2.线程的生命周期

线程的生命周期实际上是指线程的几种状态的之间的切换。

生命周期图如下：

这些状态的切换往往是通过调用Thread类中的方法来实现的，下面介绍几种常用的方法：

2.1 public static native void sleep(long millis)

复制代码作用：使当前正在运行的线程休眠millis毫秒

由于该线程是从运行状态到阻塞状态，再到可运行状态，并不是直接到可运行状态。所以中间会产生一定的时间误差，使其略长于所设参数。

该方法是在Thread类中的一个静态方法。

2.2 object.wait()

复制代码作用：暂停该线程，释放对象锁

该方法是在object类中的方法

在调用前需要先拥有某对象的锁，所以一般在 synchronized 同步块中使用

·对象锁简单的理解就是在代码中的方法上加了synchronized的锁，或者synchronized(this)的代码段

于之对应的还有类锁，指在代码中的方法上加了static和synchronized的锁(在下面还会详细涉及到)。

2.3 Thread.yield()

复制代码作用：表示暂停当前线程，让出 CPU给优先级与当前线程相同，或者优先级比当前线程更高的就绪状态的线程。

需要注意的是这和 sleep() 方法不同的是，它不会进入到阻塞状态，而是直接进入到可运行状态。

2.4 Thread.join()

复制代码会优先将该线程运行完毕，再去调用其他线程，也就是等待该线程的终止

其重载方法还有

public final void join(long millis)等待该线程终止的时间最长为 millis 毫秒

public final void join(long millis, int nanos)等待该线程终止的时间最长为 millis 毫秒 + nanos 纳秒

·线程的优先级

Java 把线程优先级分成10个级别(依次为1到10，数字越大线程的优先级越高)，线程被创建时如果没有明确声明则使用默认优先级(5)。虽然优先级越高越先被执行，但我们不能用线程优先级来规定线程的执行顺序。因为线程的执行顺序还受很多其他因素影响，例如操作系统和JVM的调度等等，所以我们只能说线程优先级越大，越先被执行的可能性越高。这里也体现了CPU调度的随机性。

1.三个优先级的常量

最小优先级(1)=Thread.MIN_PRIORITY

默认优先级(5)=Thread.NORM_PRIORITY

最大优先级(10)=Thread.MAX_PRIORITY

2.优先级的相关方法

2.1 public int getPriority()

复制代码作用：取得线程的优先级

2.2 public void setPriority(int newPriority)

复制代码作用：设置线程的优先级

·线程的同步

由于线程被执行的时间、占用cpu的时间都是不确定的，所以在有多个线程要被执行的情况下，会产生许多问题。例，在有两个线程(线程1和线程2)对同一个类的属性进行操作时，如果线程1对该属性进行“加”的操作前，线程2突然抢占了CPU来对该属性进行了“减”的操作，对该属性进行修改，那么就可能出现类似于1+1=1的结果。

为了避免上述结果的出现，这里需要调用一个synchronized关键字(同步)，来对该共享对象进行上锁，即让该共享对象在同一个时刻，只能被一个线程访问。

synchronized关键字的使用

一般加在线程前，表明该线程不允许被打断，

可以加在静态方法/方法/语句块前。

例：

public synchronized void 方法名(){}

复制代码public static synchronized void 方法名(){}

复制代码synchronized(对象名){}

复制代码

线程间的通信

我们先引进三个方法

wait()中断方法的执行，使线程等待

复制代码notify()随机唤醒等待的某一个线程

复制代码notifyall()唤醒所有处于等待的线程

复制代码

对多线程的处理，下面以对2个线程的处理为例

一般是将公共对象当作一个容器queue，并在该容器内设置一个Boolean类型的值，在将线程1和2设置为synchronized类型后，在线程1中添加判断语句，如果该Boolean型值为ture(也可以是flase)才能执行该线程的操作语句，否则进入等待(在这里调用wait()使其暂停运行，记得要在线程最后改变Boolean类型值的值)，对线程2的操作也类似，这样就能解决对线程调度顺序问题。

但这样问题并不是完全被解决，如果线程1和2都进入休眠状态，那么锁死，即两个线程都不进行。所以我们还需要在线程1和线程2的最后加上唤醒醒另一个线程的语句(这里调用notifyall()，之所以不调用notify()是因为它是随机唤醒某一个线程，如果在程序中还有线程3、线程4···，那我们想唤醒的线程有可能不被唤醒)