java中多线程学习
一、线程的基本概念（了解）
线程是一个程序内部的顺序控制流。
线程和进程的区别：
o 每个进程都有独立的代码和数据空间(进程上下文),进程间的切换会有大的开销.
o 线程可以看成是轻量级的进程,同一类进程共享代码和数据空间,每个线程有独立的运行栈和程序计数器(PC,program counter),线程切换开销小.
o 多进程:在操作系统中能同时运行多个任务(程序).
o 多线程:在同一应用程序中有多个顺序流同时执行.
Java中的线程是通过java.lang.Thread类来实现的.
VM启动时会有一个主方法(public static void main(){})所定义的线程.
可以通过创建Thread的实例来创建新的线程.
每个线程都是通过特定Thread对象所对应的方法run()来完成其操作的,方法run()称为线程体.
通过调用Thread类的start()方法来启动一个线程.
线程的理解:线程是一个程序里不同的执行路径
二、java中线程的使用
java中实现线程有两种方法：①继承Thread类重写run()方法. ②继承Runnable接口,实现run()方法.应该有三种，还有一种是实现Callable接口，并与 Future、线程池结合使用(非重点).
继承Thread类的线程写法:
public class ThreadTest01 {
public static void main(String args[]) {
MyThread myThread = new MyThread();
myThread.start(); //开启线程
for (int i = 0; i <= 3; i++) {
System.out.println("mainMethod：" + i);
}
}
}
//继承Thread的线程类
class MyThread extends Thread {
@Override
public void run() {
for (int i = 0; i <= 3; i++) {
System.out.println("MyThread：" + i);
}
}
}
运行效果:
mainMethod：0
mainMethod：1
mainMethod：2
mainMethod：3
MyThread：0
MyThread：1
MyThread：2
MyThread：3
实现Runnable接口的线程类;
public class RunnableTest {
public static void main(String[] args) {
MyRunner myRunner = new MyRunner();
Thread thread = new Thread(myRunner); // 线程代理,所有的线程对象共享同一个MyRunner实例myRunner
thread.start(); // 开启线程
for (int i = 0; i < 3; i++) {
System.out.println("mainMethod：" + i);
}
}
}
// 实现Runnable的线程类
class MyRunner implements Runnable {
@Override
public void run() {
for (int i = 0; i < 3; i++) {
System.out.println("MyRunner：" + i);
}
}
}
运行结果:
mainMethod：0
MyRunner：0
mainMethod：1
MyRunner：1
mainMethod：2
MyRunner：2
补充:
上述这行图我们想说明: 方法的入口main函数也是一个线程,称为主线程.
开辟新的线程会和原来的主线程并行运行.
三、线程方法
线程的状态:
新建状态（New）：新创建了一个线程对象。
2、就绪状态（Runnable）：线程对象创建后，其他线程调用了该对象的start()方法。该状态的线程位于可运行线程池中，变得可运行，等待获取CPU的使用权。
3、运行状态（Running）：就绪状态的线程获取了CPU，执行程序代码。
4、阻塞状态（Blocked）：阻塞状态是线程因为某种原因放弃CPU使用权，暂时停止运行。直到线程进入就绪状态，才有机会转到运行状态。阻塞的情况分三种：
（一）、等待阻塞：运行的线程执行wait()方法，JVM会把该线程放入等待池中。(wait会释放持有的锁)
（二）、同步阻塞：运行的线程在获取对象的同步锁时，若该同步锁被别的线程占用，则JVM会把该线程放入锁池中。
（三）、其他阻塞：运行的线程执行sleep()或join()方法，或者发出了I/O请求时，JVM会把该线程置为阻塞状态。当sleep()状态超时、join()等待线程终止或者超时、或者I/O处理完毕时，线程重新转入就绪状态。（注意,sleep是不会释放持有的锁）
5、死亡状态（Dead）：线程执行完了或者因异常退出了run()方法，该线程结束生命周期。
线程方法:
sleep/join/yeild方法介绍
sleep():(public static void sleep(long mills) throws InterruptedException)使得当前线程线面,暂时停止执行mills毫秒.可以直接Thread.sleep(...)或者继承Thread的类直接调用.
import java.util.Date;
public class SleepTest extends Thread {
boolean flag = true;// 定义一个标记，用来控制循环的条件
public void run() {
while (flag) {
System.out.println("子线程:" + new Date().toLocaleString());
try {
sleep(1000);// 睡眠的时如果被打断就会抛出InterruptedException异常
} catch (InterruptedException e) {
return; // 线程被中断后就返回，相当于是结束线程
}
}
}
public static void main(String args[]) {
SleepTest thread = new SleepTest();
thread.start();//开启子线程
try {
SleepTest.sleep(10000); // 或者Thread.sleep();
System.out.println("主线程睡眠了10秒种后再次启动了");
} catch (InterruptedException e) {
e.printStackTrace();
}
// 使用interrupt()方法去结束掉一个线程的执行并不是一个很好的做法
// thread.interrupt();
thread.flag = false;// 改变循环条件，结束死循环
}
}
运行结果:
Thread-0:2019-4-3 17:42:35
Thread-0:2019-4-3 17:42:36
Thread-0:2019-4-3 17:42:37
...
join():合并某个线程,有些参考书上理解为:join是Thread类的一个方法，启动线程后直接调用，即join()的作用是：“等待该线程终止”，这里需要理解的就是该线程是指的主线程等待子线程的终止。也就是在子线程调用了join()方法后面的代码，只有等到子线程结束了才能执行。如下:
Thread t = new AThread(); t.start();t.join();
为什么要用join()方法?
在很多情况下，主线程生成并起动了子线程，如果子线程里要进行大量的耗时的运算，主线程往往将于子线程之前结束，但是如果主线程处理完其他的事务后，需要用到子线程的处理结果，也就是主线程需要等待子线程执行完成之后再结束，这个时候就要用到join()方法了。
代码:
public class JoinTest extends Thread {
private String name;
public JoinTest(String name) {
super();
this.name = name;
}
@Override
public void run() {
for (int i = 0; i < 2; i++) {
System.out.println(name + "运行 : " + i);
try {
sleep((int) Math.random() * 10);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
public static void main(String[] args) {
System.out.println(Thread.currentThread().getName() + "主线程运行开始!");
JoinTest joinTest1 = new JoinTest("子线程一");
JoinTest joinTest2 = new JoinTest("子线程二");
joinTest1.start();
joinTest2.start();
System.out.println(Thread.currentThread().getName() + "主线程运行结束!");
}
}
运行结果:
main主线程运行开始!
main主线程运行结束!
子线程二运行 : 0
子线程一运行 : 0
子线程一运行 : 1
子线程二运行 : 1
我们对上述main方法改进
public static void main(String[] args) {
System.out.println(Thread.currentThread().getName() + "主线程运行开始!");
JoinTest joinTest1 = new JoinTest("子线程一");
JoinTest joinTest2 = new JoinTest("子线程二");
joinTest1.start();
joinTest2.start();
try {
joinTest1.join();// 调用join()方法合并线程，将子线程mythread合并到主线程里面.合并线程后，程序的执行的过程 // 就相当于是方法的调用的执行过程
joinTest2.join(); //可以理解为在main方法中joinTest2.run()方法(等效上图不开辟线程方法)
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName() + "主线程运行结束!");
}
修改过后:
main主线程运行开始!
子线程二运行 : 0
子线程一运行 : 0
子线程一运行 : 1
子线程二运行 : 1
main主线程运行结束!
sleep()和yield()的区别
sleep()和yield()的区别:sleep()使当前线程进入停滞状态，所以执行sleep()的线程在指定的时间内肯定不会被执行；yield()只是使当前线程重新回到可执行状态，所以执行yield()的线程有可能在进入到可执行状态后马上又被执行。
sleep 方法使当前运行中的线程睡眼一段时间，进入不可运行状态，这段时间的长短是由程序设定的，yield 方法使当前线程让出 CPU 占有权，但让出的时间是不可设定的。实际上，yield()方法对应了如下操作：先检测当前是否有相同优先级的线程处于同可运行状态，如有，则把 CPU 的占有权交给此线程，否则，继续运行原来的线程。所以yield()方法称为“退让”，它把运行机会让给了同等优先级的其他线程
另外，sleep 方法允许较低优先级的线程获得运行机会，但 yield() 方法执行时，当前线程仍处在可运行状态，所以，不可能让出较低优先级的线程些时获得 CPU 占有权。在一个运行系统中，如果较高优先级的线程没有调用 sleep 方法，又没有受到 I\O 阻塞，那么，较低优先级线程只能等待所有较高优先级的线程运行结束，才有机会运行。
setPriority(): 更改线程的优先级。
MIN_PRIORITY = 1
NORM_PRIORITY = 5(默认)
MAX_PRIORITY = 10
用法：
Thread4 t1 = new Thread4("t1");
Thread4 t2 = new Thread4("t2");
t1.setPriority(Thread.MAX_PRIORITY);
t2.setPriority(Thread.MIN_PRIORITY);
interrupt():不要以为它是中断某个线程！它只是线线程发送一个中断信号，让线程在无限等待时（如死锁时）能抛出抛出，从而结束线程，但是如果你吃掉了这个异常，那么这个线程还是不会中断的
wait()
Obj.wait()，与Obj.notify()必须要与synchronized(Obj)一起使用，也就是wait,与notify是针对已经获取了Obj锁进行操作，从语法角度来说就是Obj.wait(),Obj.notify必须在synchronized(Obj){...}语句块内。从功能上来说wait就是说线程在获取对象锁后，主动释放对象锁，同时本线程休眠。直到有其它线程调用对象的notify()唤醒该线程，才能继续获取对象锁，并继续执行。相应的notify()就是对对象锁的唤醒操作。但有一点需要注意的是notify()调用后，并不是马上就释放对象锁的，而是在相应的synchronized(){}语句块执行结束，自动释放锁后，JVM会在wait()对象锁的线程中随机选取一线程，赋予其对象锁，唤醒线程，继续执行。这样就提供了在线程间同步、唤醒的操作。Thread.sleep()与Object.wait()二者都可以暂停当前线程，释放CPU控制权，主要的区别在于Object.wait()在释放CPU同时，释放了对象锁的控制。
wait和sleep区别
共同点：
1. 他们都是在多线程的环境下，都可以在程序的调用处阻塞指定的毫秒数，并返回。
2. wait()和sleep()都可以通过interrupt()方法 打断线程的暂停状态 ，从而使线程立刻抛出InterruptedException。
如果线程A希望立即结束线程B，则可以对线程B对应的Thread实例调用interrupt方法。如果此刻线程B正在wait/sleep /join，则线程B会立刻抛出InterruptedException，在catch() {} 中直接return即可安全地结束线程。
需要注意的是，InterruptedException是线程自己从内部抛出的，并不是interrupt()方法抛出的。对某一线程调用 interrupt()时，如果该线程正在执行普通的代码，那么该线程根本就不会抛出InterruptedException。但是，一旦该线程进入到 wait()/sleep()/join()后，就会立刻抛出InterruptedException 。
不同点：
1. Thread类的方法：sleep(),yield()等
Object的方法：wait()和notify()等
2. 每个对象都有一个锁来控制同步访问。Synchronized关键字可以和对象的锁交互，来实现线程的同步。
sleep方法没有释放锁，而wait方法释放了锁，使得其他线程可以使用同步控制块或者方法。
3. wait，notify和notifyAll只能在同步控制方法或者同步控制块里面使用，而sleep可以在任何地方使用
4. sleep必须捕获异常，而wait，notify和notifyAll不需要捕获异常
所以sleep()和wait()方法的最大区别是：
sleep()睡眠时，保持对象锁，仍然占有该锁；
而wait()睡眠时，释放对象锁。
但是wait()和sleep()都可以通过interrupt()方法打断线程的暂停状态，从而使线程立刻抛出InterruptedException（但不建议使用该方法）。
sleep（）方法
sleep()使当前线程进入停滞状态（阻塞当前线程），让出CUP的使用、目的是不让当前线程独自霸占该进程所获的CPU资源，以留一定时间给其他线程执行的机会;
sleep()是Thread类的Static(静态)的方法；因此他不能改变对象的机锁，所以当在一个Synchronized块中调用Sleep()方法是，线程虽然休眠了，但是对象的机锁并木有被释放，其他线程无法访问这个对象（即使睡着也持有对象锁）。
在sleep()休眠时间期满后，该线程不一定会立即执行，这是因为其它线程可能正在运行而且没有被调度为放弃执行，除非此线程具有更高的优先级。
wait（）方法
wait()方法是Object类里的方法；当一个线程执行到wait()方法时，它就进入到一个和该对象相关的等待池中，同时失去（释放）了对象的机锁（暂时失去机锁，wait(long timeout)超时时间到后还需要返还对象锁）；其他线程可以访问；
wait()使用notify或者notifyAlll或者指定睡眠时间来唤醒当前等待池中的线程。
wiat()必须放在synchronized block中，否则会在program runtime时扔出”java.lang.IllegalMonitorStateException“异常。
关于synchronized关键字的使用:
ynchronized修饰一个方法很简单，就是在方法的前面加synchronized，public synchronized void method(){//todo}; synchronized修饰方法和修饰一个代码块类似，只是作用范围不一样，修饰代码块是大括号括起来的范围，而修饰方法范围是整个函数。如将【Demo1】中的run方法改成如下的方式，实现的效果一样。
写法一和写法二是等效的,写法一修饰的是一个方法,写法二修饰的是一个代码块,都是锁定整个方法的内容.在使用synchronized修饰方法时得注意以下几点:
1.synchronized关键字不能继承,因为虽然用它来修饰方法但是它并不属于方法定义的一部分,因此子类在覆写父类方法时如果想同步必须显式地在子类的方法前加上synchronized关键字.
2.在接口方法时不能使用synchronized关键字.
3.构造方法不能使用synchronized关键字,但是可以使用synchronized代码块来进行同步.
我们注意synchronized修饰静态方法时候,虽然syncThread1和syncThread2是不同的对象,但是他们的method是静态的都属于SyncThread类,所以他们最终共享一个方法
补充说明一点:
上图主要说明synchronized中,共享一个对象的含义.当两个并发线程(thread1和thread2)访问同一个对象(syncThread)中的synchronized代码块时，在同一时刻只能有一个线程得到执行，另一个线程受阻塞，必须等待当前线程执行完这个代码块以后才能执行该代码块。Thread1和thread2是互斥的，因为在执行synchronized代码块时会锁定当前的对象，只有执行完该代码块才能释放该对象锁，下一个线程才能执行并锁定该对象.但是右边的调用其实等效于:
不是说一个线程执行synchronized代码块时其它的线程受阻塞吗？为什么上面的例子中thread1和thread2同时在执行。这是因为synchronized只锁定对象，每个对象只有一个锁（lock）与之相关联.因为创建了两个SyncThread的对象syncThread1和syncThread2，线程thread1执行的是syncThread1对象中的synchronized代码(run)，而线程thread2执行的是syncThread2对象中的synchronized代码(run)；我们知道synchronized锁定的是对象，这时会有两把锁分别锁定syncThread1对象和syncThread2对象，而这两把锁是互不干扰的，不形成互斥，所以两个线程可以同时执行。
下面 演示下生产者和消费者的demo,说明wait和notify以及synchronized关键字的使用作为这篇文章的结束:
public class ProducerAndCustomerConsumer {
public static void main(String[] args) {
Product product = new Product();
// 生产者线程
ProducerThread p1 = new ProducerThread(product);
// ProducerThread p2 = new ProducerThread(product);
// 消费者线程
ConsumerThread c1 = new ConsumerThread(product);
// ConsumerThread c2 = new ConsumerThread(product);
p1.start();
// p2.start();
c1.start();
// c2.start();
}
}
/**
*
* 商品类
*
*/
class Product {
private int num = 0; // 当前商品数量
private int size = 5; // 允许存放的商品上限
/*
* 消费商品
*/
public synchronized void useProduct() {
if (num > 0) {
num--;
System.out.println("消费者" + Thread.currentThread().getName() + "消费资源,当前剩余资源" + num + "个");
notify(); // 通知生产者生产资源,或者notifyAll()
} else {
try {
// 如果没有资源,则消费者进入等待状态
wait();
System.out.println("消费者" + Thread.currentThread().getName() + "进入等待状态");
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
/*
* 生产商品
*/
public synchronized void createProduct() {
if (num < size) {
num++;
System.out.println("生产者" + Thread.currentThread().getName() + "生产一件商品,当前剩余资源" + num + "个");
notify(); // 通知等待的消费者,或者notifyAll()
} else {
try {
// 如果当前资源超过size,则停止生产
wait();
System.out.println("生产者" + Thread.currentThread().getName() + "进入等待状态");
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
/**
* 消费者线程
*/
class ConsumerThread extends Thread {
private Product product;
public ConsumerThread(Product product) {
super();
this.product = product;
}
@Override
public void run() {
while (true) {
try {
Thread.sleep(1500);
} catch (InterruptedException e) {
e.printStackTrace();
}
product.useProduct();
}
}
}
/**
* 生产者线程
*/
class ProducerThread extends Thread {
private Product product;
public ProducerThread(Product product) {
super();
this.product = product;
}
@Override
public void run() {
while (true) {
try {
Thread.sleep(1500);
} catch (InterruptedException e) {
e.printStackTrace();
}
product.createProduct();
}
}
}
=========================================至此线程讲解完毕=========================================
