Java学习笔记05 多线程

1.概述

进程：是一个正在执行中的程序，其实进程就是一个应用程序运行时的内存分配空间。

线程：其实就是进程中一个程序执行控制单元，一条执行路径。进程负责的是应用程序的空间的标示。线程负责的是应用程序的执行顺序。

一个进程至少有一个线程在运行，当一个进程中出现多个线程时，就称这个应用程序是多线程应用程序，每个线程在栈区中都有自己的执行空间，自己的方法区、自己的变量。

JVM在启动时会有一个进程（如java.exe），该进程中至少一个线程负责java程序执行，而且这个线程运行的调用main函数，其代码都在main方法中，该线程称之为主线程。

当产生垃圾时，收垃圾的动作，是不需要主线程来完成，因为这样，会出现主线程中的代码执行会停止，会去运行垃圾回收器代码，效率较低，所以由单独一个线程来负责垃圾回收。

随机性的原理：由于cpu的快速切换造成，哪个线程获取到了cpu的执行权，哪个线程就执行。

返回当前线程的名称：Thread.currentThread().getName()，线程的名称是由：Thread-编号定义的。编号从0开始。也可以自定义名称，如：

class Demo extends Thread
{
Demo(String name)
{
super(name);//利用Thread类中的构造函数来命名
}
}

线程要运行的代码都统一存放在了run方法中。线程要运行必须要通过类中start方法来开启。（启动后，就多了一条执行路径）

start方法的作用：

启动了线程

让jvm调用了run方法

2.创建线程

创建线程的第一种方式：继承Thread ，由子类复写run方法。

步骤：

定义类继承Thread类；

复写Thread类中的run方法，将要让线程运行的代码都存储到run方法中；

通过创建Thread类的子类对象，创建线程对象；

调用线程的start方法，开启线程，并执行run方法。

覆盖run()方法的原因：Thread类用于描述线程，该类就定义了一个功能，用于存储要运行的代码，该功能就是run()方法。

线程状态转换图：



当new了线程对象后，线程就进入了初始状态；

当该对象调用了start()方法，就进入可运行状态；

进入可运行状态后，当该对象被操作系统选中，获得CPU时间片就会进入运行状态；

进入运行状态后情况就比较复杂了

run()方法或main()方法结束后，线程就进入终止状态；

当线程调用了自身的sleep()方法或其他线程的join()方法，就会进入阻塞状态（该状态既停止当前线程，但并不释放所占有的资源）。当sleep()结束或join()结束后，该线程进入可运行状态，继续等待OS分配时间片；

线程调用了yield()方法，意思是放弃当前获得的CPU时间片，回到可运行状态，这时与其他进程处于同等竞争状态，OS有可能会接着又让这个进程进入运行状态；

当线程刚进入可运行状态（注意，还没运行），发现将要调用的资源被synchroniza（同步），获取不到锁标记，将会立即进入锁池状态，等待获取锁标记（这时的锁池里也许已经有了其他线程在等待获取锁标记，这时它们处于队列状态，既先到先得），一旦线程获得锁标记后，就转入可运行状态，等待OS分配CPU时间片；

当线程调用wait()方法后会进入等待队列（进入这个状态会释放所占有的所有资源，与阻塞状态不同），进入这个状态后，是不能自动唤醒的，必须依靠其他线程调用notify()或notifyAll()方法才能被唤醒（由于notify()只是唤醒一个线程，但我们由不能确定具体唤醒的是哪一个线程，也许我们需要唤醒的线程不能够被唤醒，因此在实际使用时，一般都用notifyAll()方法，唤醒有所线程），线程被唤醒后会进入锁池，等待获取锁标记。

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

步骤：

定义类实现Runnable接口。

覆盖Runable接口中的run方法（用于封装线程要运行的代码）。

通过Thread类创建线程对象。

将实现了Runnable接口的子类对象作为实际参数传递给Thread类中的构造函数。让线程对象明确要运行的run方法所属的对象。

调用Thread对象的start方法，开启线程，并运行Runnable接口子类中的run方法。

Runable接口出现的原因：

通过继承Thread类的方式，可以完成多线程的建立。但是这种方式有一个局限性，如果一个类已经有了自己的父类，就不可以继承Thread类，因为java单继承的局限性。可是该类中的还有部分代码需要被多个线程同时执行。只有对该类进行额外的功能扩展，java就提供了一个接口Runnable。这个接口中定义了run方法，其实run

方法的定义就是为了存储多线程要运行的代码。

所以，通常创建线程都用第二种方式。

因为实现Runnable接口可以避免单继承的局限性。

其实是将不同类中需要被多线程执行的代码进行抽取。将多线程要运行的代码的位置单独定义到接口中。为其他类进行功能扩展提供了前提。

所以Thread类在描述线程时，内部定义的run方法，也来自于Runnable接口。

实现Runnable接口可以避免单继承的局限性。而且，继承Thread，是可以对Thread类中的方法，进行子类复写的。但是不需要做这个复写动作的话，只为定义线程代码存放位置，实现Runnable接口更方便一些。所以Runnable接口将线程要执行的任务封装成了对象。

3. 同步

用于解决多线程运行的安全问题。

多线程运行的安全问题：

当多条语句在操作同一个线程共享数据时，一个线程对多条语句只执行了一部分，还没有执行完，这时另一个线程参与进来，导致共享数据出错。

多个线程在操作共享数据

有多条语句对共享数据进行运算

解决线程安全问题的办法：

对多条操作共享数据的语句在某一时段只让一个线程执行完。在执行的过程中，其他线程不可以参与执行。

Java对于多线程的安全问题提供的解决方案：

1 . 同步代码块：

synchronized(对象)//任意对象都可以，这个对象就是锁
{
...//需要被同步的代码
}

把对象作为锁，持有锁的进程可以执行同步代码块，其他进程即使获取cpu的执行权也无法运行。

定义同步的前提：

必须要有两个或者以上的线程，才需要同步。

多个线程必须保证使用的是同一个锁。

使用同步的步骤：

明确哪些代码是多线程运行的代码。

明确共享数据

明确多线程运行代码中哪些语句是操作共享数据的

2 . 同步函数：用synchronized修饰函数，该函数具备同步性。同步函数所使用的锁是自己所属的对象this，所以同步函数所使用的锁就是this锁。

当同步函数为静态函数时，静态函数加载时所属的类可能还没有产生对象，但是该类的字节码文件已经加载进内存，并且已经被封装成了对象，这个对象就是该类的字节码文件对象。所以静态加载时，只有一个对象存在，那么静态同步函数就使用的这个对象。这个对象就是 类名.class。

同步死锁：通常只要将同步进行嵌套，就可以看到现象。同步函数中有同步代码块，同步代码块中还有同步函数，这时可能会想回锁住，即为死锁。

4.线程间通信

多个线程在操作同一个资源，但是操作的动作却不一样。

通过保证在临界区上多个线程的相互排斥，线程同步完全可以避免竞争状态的发生。但是有时候，还需要线程之间相互协作。使用线程间通信，可以指定一个线程在某种条件下该做什么。

等待唤醒机制所涉及的方法：

wait:将同步中的线程处于冻结状态。释放了执行权，释放了资格。同时将线程对象存储到线程池中。

notify：唤醒线程池中某一个等待线程。

notifyAll:唤醒的是线程池中的所有线程。

这三个方法都定义在Object类中，原因是：

这些方法存在于同步中，要对持有监视器（锁）的线程进行操作。

使用这些方法时，必须要标识所属的同步的锁。

锁可以是任意对象，所以任意对象都可以调用的方法应该定义在Object类中。

wait和sleep的区别：（执行权和锁）

wait：可以指定时间，也可以不指定时间。只能由对应的notify或者notifyAll来唤醒。

sleep：必须指定时间，时间到自动从冻结状态转换成运行状态（临时阻塞状态）。

wait：线程会释放执行权，而且线程会释放锁。

sleep：线程会释放执行权，但是不会释放锁。

使线程停止：

通过stop方法就可以停止线程。但是这个方式过时了。

停止线程：原理就是：让线程运行的代码结束，也就是结束run方法。一般run方法里肯定定义循环。所以只要结束循环即可。

第一种方式：定义循环的结束标记。

第二种方式：如果线程处于了冻结状态，是不可能读到标记的，这时就需要通过Thread类中的interrupt方法，将其冻结状态强制清除。让线程恢复具备执行资格的状态，让线程可以读到标记，并结束。

显式的锁机制及显式的等待唤醒操作机制：

解决线程安全问题使用同步的形式，(同步代码块，要么同步函数)其实最终使用的都是锁机制。到了后期版本，直接将锁封装成了对象。线程进入同步就是具备了锁，执行完，离开同步，就是释放了锁。在后期对锁的分析过程中，发现，获取锁，或者释放锁的动作应该是锁这个事物更清楚。所以将这些动作定义在了锁当中，并把锁定义成对象。

所以同步是隐示的锁操作，而Lock对象是显示的锁操作，它的出现就替代了同步。

在之前的版本中使用Object类中wait、notify、notifyAll的方式来完成的。那是因为同步中的锁是任意对象，所以操作锁的等待唤醒的方法都定义在Object类中。

而现在锁是指定对象Lock。所以查找等待唤醒机制方式需要通过Lock接口来完成。而Lock接口中并没有直接操作等待唤醒的方法，而是将这些方式又单独封装到了一个对象中。这个对象就是Condition，将Object中的三个方法进行单独的封装。并提供了功能一致的方法 await()、signal()、signalAll()体现新版本对象的好处。代码示例：

class BoundedBuffer
{
final Lock lock = new ReentrantLock();
final Condition notFull = lock.newCondition();
final Condition notEmpty = lock.newCondition();
final Object[] items = new Object[100];
int putptr, takeptr, count;

public void put(Object x) throws InterruptedException
{
lock.lock();
try
{
while (count == items.length)
notFull.await();
items[putptr] = x;
if (++putptr == items.length)
{
putptr = 0;
}
++count;
notEmpty.signal();
}
finally
{
lock.unlock();
}
}

public Object take() throws InterruptedException
{
lock.lock();
try
{
while (count == 0)
notEmpty.await();
Object x = items[takeptr];
if (++takeptr == items.length)
{
takeptr = 0;
}
--count;
notFull.signal();
return x;
}
finally
{
lock.unlock();
}
}
}

守护线程：

实际可以理解为后台线程，当把某些线程标记为后台线程后，它将具备一个特殊的含义。后台线程的特点是开启后和前台线程共同使用cpu，但是当所有的前台线程都结束后，后台线程会自动结束。

Thread类中提供了方法：setDaemon(boolean on);

注意要在线程启动前调用，传入true将该线程设置为守护线程。

线程合并：join

一个线程在运算过程中临时加入另一个线程，原线程将被冻结直到加入的这个线程退出才会继续执行。

设置线程的优先级

setPriority(int );

可以参考参数：MAX_PRIORITY、MIN_PRIORITY、NORM_PRIORITY

临时释放cpu：yield

通过调用yield方法可以强制线程临时释放cpu使用权。