16 Java的线程
基本概念：程序-进程-线程
程序(program)是为完成特定任务、用某种语言编写的一组指令的集合。即指一段静态的代码，静态对象。
进程(process)是程序的一次执行过程，或是正在运行的一个程序。动态过程：有它自身的产生、存在和消亡的过程。
如：运行中的QQ，运行中的MP3播放器
程序是静态的，进程是动态的
线程(thread)，进程可进一步细化为线程，是一个程序内部的一条执行路径。
若一个程序可同一时间执行多个线程，就是支持多线程的
多线程，一个进程（一个程序运行时），可以分化为并行执行多个线程（多个子程序）。
举例：线程相当于一条河，线程就相当于河流的分支。
什么时候需要多线程呢？
程序需要同时执行两个或多个任务.
程序需要实现一些需要等待的任务时，如用户输入，文件读写操作、网络操作、搜索等。
举例：有一个进程是浏览器，看网页，比如用百度搜索（线程），需要等待百度那边的服务器通过网络给你展示搜索的内容，这个过程需要时间，如果网速越慢时间越长。
在等待过程中，这个浏览器是一直占用CPU的资源，考虑说在浏览器等待百度服务器响应的这段时间，先让这个进程占用的CPU干其他事，等响应回来了数据，再继续使用。
需要一些后台运行的程序时。
因为多线程是进程的支流，当分支之后，就各走各的
假设在进程上跑的代码是主程序，当其中的第三行代码是开启线程的，那么，开启线程之后线程运行的代码就和主程序并行（他们之间互不干扰）。
多线程的创建和启动
Java语言的JVM允许程序运行多个线程，它通过java.lang.Thread类来实现。
Thread类的特性
1. 每个线程都是通过某个特定Thread对象的run()方法来完成操作的，经常把run()方法的主体称为线程体。（想要在开启的多线程中运行的代码逻辑，就写到run方法里）。
注意：run()方法的作用不是启动线程，而是线程体，start()方法调用run()方法时叫执行线程。
2. 通过该Thread对象的start()方法来调用这个线程
start()方法用来启动线程，本质上就开始运行run()方法，也就是执行start()方法，start()方法会自动调用run()方法。
Thread类
创建线程需要Thread类，Thread类包含4个构造方法，如下
1. Thread()：创建新的Thread对象
2. Thread(String threadname)：创建线程并指定线程实例名
3. Thread(Runnable target)：指定创建线程的目标对象，它实现了Runnable接口中的run方法
4. Thread(Runnable target, String name)：创建新的Thread对象
先介绍1，2两种方式。
继承Thread类
方式1步骤如下：
1）定义子类继承Thread类。
2）子类中重写Thread类中的run方法。
3） 创建Thread子类对象，即创建了线程对象。
4） 调用线程对象start方法：启动线程，调用run方法。
代码：
/** * 继承Thread类方式实现多线程 * @author leak * */ public class TestThread extends Thread{ @Override public void run() { System.out.println("多线程运行的代码"); for(int i = 0 ; i < 5 ; i++) { System.out.println("这是多线程的逻辑代码："+i); } } } //测试类 /** * 1.测式线程类 * @author leak * */ public class Test { public static void main(String[] args) { Thread t = new TestThread(); t.start();//启动线程 System.out.println("-------------"); System.out.println("-------------"); System.out.println("-------------"); /** * 多次运行这个main方法之后 * 我们发现main方法中打印的3行于开启线程运行run()方法中的打印语句混合起来，因为主线程和支线程同时运行的结果，但是有可能主线程运行完才运行支线程（CPU特别好的时候） * main方法从上到下执行，到t.start()开启线程后，那边的支线程执行语句，这边的主线程还是继续往下执行(无论支线程是否执行完)这就是异步。 * * 补充： 如果是同步，也就是main方法执行到t.start()的时候，跳去执行start()体内的语句，执行完后，返回来结束t.start()语句，继续往下执行，这就是同步（这里不是多线程运行的方式，只是举例说明同步）。 * 多线程差不多算异步执行。补充：同步就是从上到下的执行顺序。 * */ } }
实现Runnable接口
方式2步骤如下：
1）定义子类，实现Runnable接口。
2）子类中重写Runnable接口中的run方法。
3）通过Thread类含参构造器创建线程对象。
4）将Runnable接口的子类对象作为实际参数传递给Thread类的构造方法中。
5）调用Thread类的start方法：开启线程，调用Runnable子类接口的run方法。
代码：
/** * 2. 通过实现Runnable接口方式实现多线程 * @author leak * */ public class TestRuunable implements Runnable{ @Override public void run() { //Thread.currentThread().getName()作用：获取当前线程的线程名 System.out.println("当前线程名："+Thread.currentThread().getName()+"，Runnable多线程运行的代码"); for(int i = 0 ; i < 5 ; i++) { System.out.println("这是线程："+Thread.currentThread().getName()+" 的逻辑代码："+i); } } } //测试类 /** * 这个和方式1有什么区别呢？ * 方式1是继承了Thread类然后重写run()方法的，因为Java不支持多继承，所以这种方式有限制， * 不必为了重写run()方法而继承Thread类。而且Thread类的run()方法也是实现Runnable接口的。 * 所以方式2直接省略继承Thread类，直接实现Runnable接口，重写run()方法，Java是支持多实现的，所以使用方式2可扩展性好 * 但是线程启动需要Thread类，所以把实现Runnable接口的类传给Thread类，然后通过Thread的实例对象调用start方法启动线程。 * * @author leak * */ public class Test2 { public static void main(String[] args) { //2.通过传Runnable对象去实现多线程 Thread t = new Thread(new TestRuunable());//这里是使用默认的线程名Thread-0，默认0号开始 t.start();//启动线程1 //另外方式2还可以给线程起名字 Thread t2 = new Thread(new TestRuunable(),"线程2");//自定义线程名 t2.start();//启动线程2 //补充：线程可以启动多条，不同的线程实例对象可以开启不同的线程。 } }
继承方式和实现方式的联系和区别
方式1：继承Thread: 线程代码存放Thread子类run方法中。重写run方法
方式2：实现Runnable：线程代码存在接口的子类的run方法。实现run方法
一般使用实现接口方式来实现多线程（方式2），原因如下：
1）避免了单继承的局限性
2）多个线程可以共享同一个接口实现类的对象，非常适合多个相同线程来处理同一份资源。
一般使用实现接口方式来实现多线程
上面方式2的代码，都是使用匿名实现类来传递给Thread类，十分耗资源，方式2可以共享同一个接口实现类的对象，代码如下：
代码：
/** * 2. 通过实现Runnable接口方式实现多线程 * @author leak * */ public class TestRuunable implements Runnable{ int count = 0 ; //测试方式2多线程之间的共享同一个对象，所以方式2才会共享count属性 @Override public void run() { //Thread.currentThread().getName()作用：获取当前线程的线程名 System.out.println("当前线程名："+Thread.currentThread().getName()+"，Runnable多线程运行的代码"); for(int i = 0 ; i < 5 ; i++) {//Test2测试类那边有两个开启线程，因为传递是同一个对象，这里第二个线程最后的count结果是10 count++; System.out.println("这是线程："+Thread.currentThread().getName()+" 的逻辑代码："+count); } } } //测试类 public class Test2 { public static void main(String[] args) { //2.通过传Runnable对象去实现多线程 Runnable run = new TestRuunable();//下面两个线程实例对象传递的都是同一个Runnable实现类，所以共享对象里面的资源/属性 Thread t = new Thread(run);//这里是使用默认的线程名Thread-0，默认0号开始 t.start();//启动线程1 //另外方式2还可以给线程起名字 Thread t2 = new Thread(run,"线程2");//自定义线程名 t2.start();//启动线程2 //补充：线程可以启动多条，不同的线程实例对象可以开启不同的线程。 } }
注意：上面说过线程之间运行互不干扰，上面的代码的count变量为什么共享了？因为上面的代码采用方式2，方式2通过实现Runnable接口创建线程实例对象，然后方式2需要Thread类，而且需要传递一个实现Runnable的实例对象给Thread类，这样方式2才能启动线程，因为传递的是同一对象，所以不同线程操作的是同一对象，所以属性才会共享。
使用多线程的优点
1. 提高应用程序的响应。对图形化界面更有意义，可增强用户体验。
2. 提高计算机系统CPU的利用率(前面浏览器那个例子说明过)
3. 改善程序结构。将既长又复杂的进程分为多个线程，独立运行，利于理解和修改
第三点是什么意思呢，比如一个方法有1000行代码，前300，中间300，最后400行，这三段代码没有因果关系（也就是代码没有限制执行顺序），这种情况我们就可以使用线程处理，把前中后三段代码分别放在不同线程中去运行，这样三段代码就是并行运行的。
例子：再比如下载一个视频时，采用多线程方式下载视频，假设视频大小是900M，开启三个线程，线程1从0KB位置下载，线程2从300M位置开始下载，线程3从600M位置开始下载，三个线程下载完成后，再把各自线程下载好的视频合并在一起，这样下载视频是不是快了很多。
Thread类的有关方法1
void start(): 启动线程，并执行对象的run()方法
run(): 线程在被调度时执行的操作
String getName(): 返回线程的名称
void setName(String name):设置该线程名称
static currentThread(): 返回当前线程
代码：
/** * Thread类的有关方法1 * * @author leak * */ public class Test3 { public static void main(String[] args) { Runnable run = new TestRun(); Runnable run1 = new TestRun(); // 线程传递不同的实现Runnable接口的实例对象，不会共享属性count这里 Thread t0 = new Thread(run); Thread t1 = new Thread(run1); // 1线程对象.setName()设置线程名 t0.setName("线程1"); // 2不同线程对象.start()都会开启一个线程 t1.start(); t0.start(); // 3线程对象.getName()获取当前线程名，4线程类.currentThread()返回当前线程 System.out.println(t0.getName() + "当前线程对象：" + Thread.currentThread()); } } class TestRun implements Runnable { int count;// 传递同一TestRun对象给Thread类时，共享对象（包含对象的其他） @Override public void run() { // Thread.currentThread().getName()作用：获取当前线程的线程名 System.out.println("当前线程名：" + Thread.currentThread().getName() + "，Runnable多线程运行的代码"); for (int i = 0; i < 5; i++) {// Test2测试类那边有两个开启线程，因为传递是同一个对象，这里第二个线程最后的count结果是10 count++; System.out.println("这是线程：" + Thread.currentThread().getName() + " 的逻辑代码：" + count); } } }
线程的优先级
优先级越高，线程执行的概率就越高，但不一定执行。
MAX_PRIORITY（10）; 最高优先级是10级
MIN _PRIORITY （1）; 最低是1级
NORM_PRIORITY （5）; 默认是5级
涉及的方法：
getPriority() ：返回线程优先值
setPriority(int newPriority) ：改变线程的优先级
线程创建时继承父线程的优先级
代码：
/** * 线程的优先级，线程优先级有10级，级数越大，优先级越高，优先级高的线程有大概率被先执行，但是不一定都执行 * 默认优先级是5，子类继承父类线程，优先级也会被继承 * * @author leak * */ public class Test4 { public static void main(String[] args) { Runnable run = new TestRun(); // 线程传递不同的实现Runnable接口的实例对象，不会共享属性count，这里是共享 Thread t0 = new Thread(run); Thread t1 = new Thread(run); // 不同线程对象.start()都会开启一个线程 t1.start(); t0.start(); //getPriority()获取当前线程优先级 System.out.println("当前 "+t0.getName()+" 线程的优先级："+t0.getPriority()); System.out.println("当前 "+t1.getName()+" 线程的优先级："+t1.getPriority()); //setPriority(级数)设置线程优先级 t0.setPriority(10); //重新获取优先级 System.out.println("当前 "+t0.getName()+" 线程的优先级："+t0.getPriority()); } } class TestRun1 implements Runnable { int count;// 传递同一TestRun对象给Thread类时，共享对象（包含对象的其他） @Override public void run() { // Thread.currentThread().getName()作用：获取当前线程的线程名 System.out.println("当前线程名：" + Thread.currentThread().getName() + "，Runnable多线程运行的代码"); for (int i = 0; i < 5; i++) {// Test2测试类那边有两个开启线程，因为传递是同一个对象，这里第二个线程最后的count结果是10 count++; System.out.println("这是线程：" + Thread.currentThread().getName() + " 的逻辑代码：" + count); } } }
Thread类的有关方法2
static void yield()：线程让步
1. 暂停当前正在执行的线程，把执行机会让给优先级相同或更高的线程
2. 若队列中没有同优先级的线程，忽略此方法
join() ：当某个程序执行流中调用其他线程的 join() 方法时，调用线程将被阻塞，直到 join() 方法加入的 join 线程执行完为止
1. 低优先级的线程也可以获得执行
static void sleep(long millis)：(指定时间:毫秒)，线程睡眠
1. 令当前活动线程在指定时间段内放弃对CPU控制,使其他线程有机会被执行,时间到后重排队。
2. 抛出InterruptedException异常
stop(): 强制线程生命期结束，该方法已经弃用，因为会导致很多问题发生，具体原因百度。这里就不演示了
interrupt()：该方法给线程设置中止状态，但不会马上终止线程，代替上面的stop方法，不过要结合下面两个方法才能停止线程。
interrupted()：判断线程是否中断，并清理线程的中止状态。
isInterrupted()：判断线程是否中断，不会清理线程的中止状态。
boolean isAlive()：返回boolean，判断线程是否还活着
补充：stop()和interrupt()区别在于，stop()是马上停止线程，interrupt()是把线程停止控制权给你，你想在哪里停止都可以。
代码：
/** * 1.线程让步yield()，让优先级高的线程大概率优先执行，但不一定都执行 * 2.线程插队join()，指定线程在哪里执行完（优先级低的也可以）才继续往下执行，该线程执行期间，主线程阻塞状态 * 3.线程睡眠sleep()，让线程睡眠多久，放弃对CPU控制，使其他线程有机会被执行 * 4.线程强制停止stop()，立刻停止线程，存在安全问题，该方法已过时，采用interrupt()代替 * 5.线程停止状态interrupt()，给线程设置停止状态，然后利用isInterrupted()判断线程的停止状态，决定是否停止线程 * 6.线程判断存活isAlive()，判断线程生命周期是否已经结束 * @author leak * */ public class Test5 { public static void main(String[] args) throws InterruptedException { Runnable run = new TestRun2(); Runnable run1 = new TestRun2(); // 传递同一对象,共享里面的变量 Thread t0 = new Thread(run); Thread t1 = new Thread(run); t0.start();// 启动线程,一直执行run方法 t1.start(); // t0.stop();//线程停止，直接终止该线程生命周期，不过现在该方法已过期，存在各种安全问题 //isAlive()判断线程是否存活，返回布尔值 System.out.println(t0.isAlive()); System.out.println("---------------------"); System.out.println("---------------------"); t0.join();//1. 指定线程在哪里执行完，再执行下面的语句，也就是从上往下执行，当前语句没有执行完，就不会往下执行。 System.out.println("---------------------"); // 2. Thread.sleep(300);//只有线程阻塞时，interrupt()才会生效,所以这里手动阻塞线程3秒 // 或者这里展示开启2个线程,t0开启线程时,t1也开启了,t1开启时,t0线程处在阻塞期间, // 所以会执行t0.interrupt()改变t0线程的终止状态为true,因为只有线程处于阻塞期间,interrupt()才会生效 // 3. t0.interrupt();//判断到线程t0已经阻塞,线程终止状态改为true } } class TestRun2 implements Runnable { int count = 1; @Override public void run() { for (int i = 0; i < 5; i++) { // 4. isInterrupted():判断线程的终止状态,如果为终止就返回true,否则返回false if (Thread.currentThread().isInterrupted()) { System.out.println("线程停止状态"); break;// 线程的终止状态为true,手动停止线程 } else { if (i % 2 == 0) { //设置线程让步的条件 //5. 线程让步yield()，有一定概率让步，和 setPriority(级数)设置线程优先级一样，优先级高的也不一定优先执行 Thread.yield(); } System.out.println("线程: " + Thread.currentThread().getName() + "正在运行: " + count); ++count;// 因为有两个线程开启了,而且是变量共享,所以i<5会被执行2次 } } } }
线程的生命周期
JDK中用Thread.State枚举表示了线程的几种状态
要想实现多线程，必须在主线程中创建新的线程对象。Java语言使用Thread类及其子类的对象来表示线程，在它的一个完整的生命周期中通常要经历如下的五种状态：
1. 新建： 当一个Thread类或其子类的对象被声明并创建时，新生的线程对象处于新建状态
2. 就绪：处于新建状态的线程被start()后，将进入线程队列等待CPU时间片，此时它已具备了运行的条件
3. 运行：当就绪的线程被调度并获得处理器资源时,便进入运行状态， run()方法定义了线程的操作和功能
4. 阻塞：在某种特殊情况下，被人为挂起或执行输入输出操作时，让出 CPU 并临时中止自己的执行，进入阻塞状态
5. 死亡：线程完成了它的全部工作或线程被提前强制性地中止
线程的生命周期执行状态图如下：
总结：线程从创建，然后start()方法启动线程时，线程处于就绪状态，如果获得CPU执行权就执行run()方法来运行线程，如果没有获得CPU执行权就一直处于就绪状态（可通过yield()方法线程让步就失去了CPU执行权），当然线程处于运行状态时，可以通过4种方法让线程处于阻塞状态，阻塞状态结束后，线程就会回到就绪状态，等待获取CPU的执行权，当然如果线程很顺利的执行一直到线程结束，或是线程异常/其他突发情况导致线程结束，线程就是处于死亡状态。
补充：就绪-运行-阻塞3个状态可以是一个无限循环，直到线程运行状态结束，才会结束循环。
线程的同步
上面的例子如果是多线程运行，就算有if判断取款金额不能大于余额，一样没有进入if语句里面，例子代码如下：
/** * 例子：多线程共享资源，导致线程安全问题 提款，判断账号钱够不够 * 多线程调用这个方法，就有问题，线程共享资源时，一个线程在执行这个方法没有完毕时，另一个线程又开始执行这个方法 导致线程安全问题 * * @author leak * */ public class Test6 { public static void main(String[] args) { Acount acount = new Acount();// 创建一个账号 Runnable wei_xin = new User(acount, 2000);// 传递账号 并初始化，并且设置消费金额 Runnable zhifu_bao = new User(acount, 2000);// 传递账号 并初始化，并且设置消费金额 Thread t0 = new Thread(wei_xin, "微信"); Thread t1 = new Thread(zhifu_bao, "支付宝"); // 2个线程启动，看控制台输出，明显最后结果是-1000，为什么没有进入if语句判断呢 t0.start(); t1.start(); } } //账号 class Acount { public static int money = 3000;// 静态变量，全局共享 public void drawing(int m) { String name = Thread.currentThread().getName();// 当前线程名称 // 取款金额超出余额，提示金额不足 if (money < m) { System.out.println(name + "操作，账号金额不足：" + money); } else { System.out.println(name + "操作，账号原有金额：" + money); System.out.println(name + "操作，取款金额：" + m); System.out.println(name + "取款操作: 原金额" + money + " - 取款金额：" + m); money -= m; System.out.println(name + "操作，取款后的余额：" + money); } } } class User implements Runnable { Acount acount;// 给用户一个账号属性 int money; // 消费金额 public User() { } // 创建线程User类时就初始化一个账号和消费金额给用户 public User(Acount acount, int money) { this.acount = acount; this.money = money; } @Override public void run() { // 把对象初始化的money传递给drawing方法 acount.drawing(money); } }
上面的代码运行结果，最后是-1000，并没有进入到if语句判断金额不足里面。
问题的原因：
当多条语句在操作同一个线程共享数据时，一个线程对多条语句只执行了一部分，还没有执行完，另一个线程参与进来执行。导致共享数据的错误。
解决思路:
对多条操作共享数据的语句，只能让一个线程都执行完，在执行过程中，其他线程不可以参与执行。
怎么实现解决思路呢，那就要用到synchronized同步锁机制。
synchronized同步锁机制
Java对于多线程的安全问题提供了专业的解决方式：
同步机制
一、synchronized还可以放在方法声明中，表示整个方法
为同步方法。
例如：
public synchronized void show (String name){
….
}
二、synchronized (对象）{
// 需要被同步的代码；
}
1）第一种的情况1 在方法上加synchronized关键字，锁的是整个对象（这里的对象指的是共享资源的对象），不是锁被修饰的方法。
2）第一种情况2 , 不同的共享对象是不同的锁，如果你传了两个不同的对象给不同的Runnable类，那么就有两个synchronized锁，两个锁是分别运行的，互相不干涉。所以直接在普通方法加synchronized是同一个共享对象可以锁住，但是不同共享对象，怎么锁呢，直接在synchronized前面加static修饰符（相当于static修饰的变量共享，所以static synchronized就是共享锁），就是不同对象共享一个锁。
第一种方法的两种情况代码如下：
1）情况（被synchronized修饰的普通方法，锁的是同一共享对象，不是方法）：
/** * 第1种方法的情况1，同一个共享对象，只要在普通方法加synchronized就可以锁住共享对象 * * @author leak * */ public class Test6 { public static void main(String[] args) { Acount acount = new Acount();// 创建一个账号，这里就是共享对象 //注意这里的acount是同一个共享对象，所以共享静态变量money=3000 Runnable wei_xin = new User(acount, 2000);// 传递账号 并初始化，并且设置消费金额 Runnable zhifu_bao = new User(acount, 2000);// 传递账号 并初始化，并且设置消费金额 //创建2个线程 Thread t0 = new Thread(wei_xin, "微信"); Thread t1 = new Thread(zhifu_bao, "支付宝"); // 2个线程启动 t0.start(); t1.start(); } } //账号 class Acount { public static int money = 3000;// 静态变量，全局共享 //synchronized同步 public synchronized void drawing(int m) { String name = Thread.currentThread().getName();// 当前线程名称 // 取款金额超出余额，提示金额不足 if (money < m) { System.out.println(name + "操作，取款金额："+m+", 银行卡账号金额不足剩：" + money); } else { System.out.println(name + "操作，银行卡账号原有金额：" + money); System.out.println(name + "操作，取款金额：" + m); System.out.println(name + "取款操作: 银行卡原金额" + money + " - 取款金额：" + m); money -= m; System.out.println(name + "操作，取款后的银行卡余额：" + money); } } //这里加了一个不同名字同内容的方法，就是为了说明synchronized锁住的是同一对象，不是锁住方法 public synchronized void drawing1(int m) { String name = Thread.currentThread().getName();// 当前线程名称 // 取款金额超出余额，提示金额不足 if (money < m) { System.out.println(name + "操作，取款金额："+m+", 银行卡账号金额不足剩：" + money); } else { System.out.println(name + "操作，银行卡账号原有金额：" + money); System.out.println(name + "操作，取款金额：" + m); System.out.println(name + "取款操作: 银行卡原金额" + money + " - 取款金额：" + m); money -= m; System.out.println(name + "操作，取款后的银行卡余额：" + money); } } } class User implements Runnable { Acount acount;// 给用户一个账号属性 int money; // 消费金额 public User() { } // 创建线程User类时就初始化一个账号和消费金额给用户 public User(Acount acount, int money) { this.acount = acount; this.money = money; } /** * 重点：这里很详细说明了为什么在普通方法加synchronized是锁对象，而不是锁方法 * 这里可以在下面的if语句打断点，然后调试模式， * 调式模式运行，可以看到左边分别有两个线程，一个是微信，一个是支付宝 * 可以手动选择哪个线程先进行调试，调试完其中一个线程，发现余额剩1000， * 然后再调试另外一个线程发现，虽然是另外一个线程调用的是另一个方法，但是直接跳进了余额不足的if语句里， * 所以这里虽然分别调用了两个方法drawing/drawing1，但是最后两个方法的操作的对象资源都是共享的 */ @Override public void run() { // 把对象初始化的money传递给drawing方法 //下面不同线程分别调用不同的被synchronized修饰的普通方法，但是资源属性money=3000,还是被共享了， //所以synchronized锁的是共享对象 if(Thread.currentThread().getName().equals("微信")) { acount.drawing(money); }else { acount.drawing1(money); } } }
2) 情况（不同的共享对象是不同的锁，还介绍了不同的共享对象怎么使用共享锁static synchronized修饰）
/** * 第1种方法的情况2，不同共享对象，只要在普通方法加static synchronized就可以共享锁 去锁不同共享对象 * 如果方法没有加static修饰，如果还传递不同的共享对象，那么就有两个不同的锁，控制台最后输出-1000，因为不是同一共享对象，而且是两个锁，所以锁不住 * 但是如果加了static修饰，就会共享锁，不同共享对象使用共享锁 * * @author leak * 注意：下面的Acount1和User1，不要使用Test6的Acount和User混淆了 */ public class Test7 { public static void main(String[] args) { Acount1 a1 = new Acount1();// 创建一个账号，这里就是共享对象 Acount1 a2 = new Acount1(); // 重点： 注意这里的a1和a2是不同的共享对象 Runnable wei_xin = new User1(a1, 2000);// 传递账号 并初始化，并且设置消费金额 Runnable zhifu_bao = new User1(a2, 2000);// 传递账号 并初始化，并且设置消费金额 // 创建2个线程 Thread t0 = new Thread(wei_xin, "微信"); Thread t1 = new Thread(zhifu_bao, "支付宝"); // 2个线程启动 t0.start(); t1.start(); } } //账号 class Acount1 { public static int money = 3000;// 静态变量，全局共享 // synchronized同步 public static synchronized void drawing(int m) { String name = Thread.currentThread().getName();// 当前线程名称 // 取款金额超出余额，提示金额不足 if (money < m) { System.out.println(name + "操作，取款金额：" + m + ", 银行卡账号金额不足剩：" + money); } else { System.out.println(name + "操作，银行卡账号原有金额：" + money); System.out.println(name + "操作，取款金额：" + m); System.out.println(name + "取款操作: 银行卡原金额" + money + " - 取款金额：" + m); money -= m; System.out.println(name + "操作，取款后的银行卡余额：" + money); } } } class User1 implements Runnable { Acount1 acount;// 给用户一个账号属性 int money; // 消费金额 public User1() { } // 创建线程User类时就初始化一个账号和消费金额给用户 public User1(Acount1 acount, int money) { this.acount = acount; this.money = money; } @Override public void run() { // 把对象初始化的money传递给drawing方法 Acount1.drawing(money);//静态方法调用，共享锁 锁住不同共享对象 } }
第二种方法的两种情况代码如下：
1）情况（如果传递同一共享对象，被synchronized修饰的代码块加了同步锁），这种和上面第一种方法情况1基本一样，只是方式不一样。
/** * 第2种方法的情况1，synchronized(this){代码块}被加了同步锁，前提是传递同一共享对象 * * @author leak 注意：下面的Acount2和User2，不要使用Test7的Acount1和User1混淆了 */ public class Test8 { public static void main(String[] args) { Acount2 a1 = new Acount2();// 创建一个账号，这里就是共享对象 // 重点：这里传递的是同一a1共享对象 Runnable wei_xin = new User2(a1, 2000);// 传递账号 并初始化，并且设置消费金额 Runnable zhifu_bao = new User2(a1, 2000);// 传递账号 并初始化，并且设置消费金额 // 创建2个线程 Thread t0 = new Thread(wei_xin, "微信"); Thread t1 = new Thread(zhifu_bao, "支付宝"); // 2个线程启动 t0.start(); t1.start(); } } //账号 class Acount2 { public static int money = 3000;// 静态变量，全局共享 public void drawing(int m) { /** * synchronized(this){代码块} 给代码块添加同步锁 * 其实这里和第一种方法的情况1很像，只不过一个是在方法上加synchronized修饰符， * 一个是在方法里添加synchronized(this){代码块}， * 效果都是一样的 */ synchronized (this) { String name = Thread.currentThread().getName();// 当前线程名称 // 取款金额超出余额，提示金额不足 if (money < m) { System.out.println(name + "操作，取款金额：" + m + ", 银行卡账号金额不足剩：" + money); } else { System.out.println(name + "操作，银行卡账号原有金额：" + money); System.out.println(name + "操作，取款金额：" + m); System.out.println(name + "取款操作: 银行卡原金额" + money + " - 取款金额：" + m); money -= m; System.out.println(name + "操作，取款后的银行卡余额：" + money); } } } } class User2 implements Runnable { Acount2 acount;// 给用户一个账号属性 int money; // 消费金额 public User2() { } // 创建线程User类时就初始化一个账号和消费金额给用户 public User2(Acount2 acount, int money) { this.acount = acount; this.money = money; } @Override public void run() { // 把对象初始化的money传递给drawing方法 acount.drawing(money);// } }
2）情况（传递不同的共享对象，利用锁住类 实现不同对象共享锁）
/** * 第2种方法的情况2，synchronized(共享类.class){代码块}被加了同步锁，传递不同共享对象实现共享锁 * * @author leak 注意：下面的Acount3和User3，不要使用Test8的Acount2和User2混淆了 */ public class Test9 { public static void main(String[] args) { Acount3 a1 = new Acount3();// 创建一个账号，这里就是共享对象 Acount3 a2 = new Acount3(); // 重点： 注意这里的a1和a2是不同的共享对象 Runnable wei_xin = new User3(a1, 2000);// 传递账号 并初始化，并且设置消费金额 Runnable zhifu_bao = new User3(a2, 2000);// 传递账号 并初始化，并且设置消费金额 // 创建2个线程 Thread t0 = new Thread(wei_xin, "微信"); Thread t1 = new Thread(zhifu_bao, "支付宝"); // 2个线程启动 t0.start(); t1.start(); } } //账号 class Acount3{ public static int money = 3000;// 静态变量，全局共享 // synchronized同步 public void drawing(int m) { synchronized (Acount3.class) {//传递共享类实现不同共享对象使用共享锁 String name = Thread.currentThread().getName();// 当前线程名称 // 取款金额超出余额，提示金额不足 if (money < m) { System.out.println(name + "操作，取款金额：" + m + ", 银行卡账号金额不足剩：" + money); } else { System.out.println(name + "操作，银行卡账号原有金额：" + money); System.out.println(name + "操作，取款金额：" + m); System.out.println(name + "取款操作: 银行卡原金额" + money + " - 取款金额：" + m); money -= m; System.out.println(name + "操作，取款后的银行卡余额：" + money); } } } } class User3 implements Runnable { Acount3 acount;// 给用户一个账号属性 int money; // 消费金额 public User3() { } // 创建线程User类时就初始化一个账号和消费金额给用户 public User3(Acount3 acount, int money) { this.acount = acount; this.money = money; } @Override public void run() { // 把对象初始化的money传递给drawing方法 acount.drawing(money);// } }
3）情况（不同共享对象，不同锁，这里代码和上面情况2，只是改了点代码，这里只放修改的代码）
//Acount3类的方法 // synchronized同步,这里形参根据传递不同的共享对象，实现不同锁 public void drawing(int m,Acount3 a) { synchronized (a) {//传递不同共享对象，使用不同锁 String name = Thread.currentThread().getName();// 当前线程名称 // 取款金额超出余额，提示金额不足 if (money < m) { System.out.println(name + "操作，取款金额：" + m + ", 银行卡账号金额不足剩：" + money); } else { System.out.println(name + "操作，银行卡账号原有金额：" + money); System.out.println(name + "操作，取款金额：" + m); System.out.println(name + "取款操作: 银行卡原金额" + money + " - 取款金额：" + m); money -= m; System.out.println(name + "操作，取款后的银行卡余额：" + money); } } } //User3的run方法 @Override public void run() { // 把对象初始化的money传递给drawing方法 acount.drawing(money,acount);// }
总结：两个方法，如果针对对象要加同步锁，那synchronized就加在方法上，如果针对某一段代码需要加同步锁，那就直接在代码块上加同步锁。
线程的死锁问题
死锁
不同的线程分别占用对方需要的同步资源不放弃，都在等待对方放弃自己需要的同步资源，就形成了线程的死锁
解决方法
1. 专门的算法、原则，比如加锁顺序一致
2. 尽量减少同步资源的定义（例如：多个线程使用一个共享资源，如果多个线程使用多个共享资源，导致死锁概率大，也就是尽量保持 多对一，不要多对多关系），尽量避免锁未释放的场景。
如果上面概念听不懂，那举个例子：
比如线程a0，需要执行方法f0，线程a1需要执行方法f1，前提：f0和f1都是有同步锁的方法，现在的情况是，a0调用f1方法并且一直没有执行完f1（也就是卡住了），a1调用f0方法并且一直没有执行完f0，导致a0和a1都在等对方释放方法，对方都不释放，这样就形成了线程的死锁。
线程通信
wait() 与 notify() 和 notifyAll()
1. wait()：令当前线程挂起并放弃CPU、同步资源，使别的线程可访问并修改共享资源，而当前线程排队等候再次对资源的访问
2. notify()：唤醒正在排队等待同步资源的线程中优先级最高者结束等待
3. notifyAll ()：唤醒正在排队等待资源的所有线程结束等待.
Java.lang.Object提供的这三个方法只有在synchronized方法或synchronized代码块中才能使用，否则会报java.lang.IllegalMonitorStateException异常
这里三个方法有什么用呢，比如上面synchronized修饰方法，第二种方法情况3运行结果，都是微信先执行线程，然后才是支付宝线程执行（因为微信线程先开启），那怎么先支付宝线程，后执行微信线程呢，这就要使用到线程等待wati()和线程唤醒notify()了。
代码：
/** * 注意下面的是 Acount5和User5类 * * @author leak * */ public class Test10 { public static void main(String[] args) { Acount5 acount = new Acount5();// 创建一个账号，这里就是共享对象 // 注意这里的acount是同一个共享对象，所以共享静态变量money=3000 Runnable wei_xin = new User5(acount, 2000);// 传递账号 并初始化，并且设置消费金额 Runnable zhifu_bao = new User5(acount, 2000);// 传递账号 并初始化，并且设置消费金额 // 创建2个线程 Thread t0 = new Thread(wei_xin, "微信"); Thread t1 = new Thread(zhifu_bao, "支付宝"); // 2个线程启动 t0.start();// 因为微信线程先启动，所以默认微信先执行完线程 t1.start(); } } //账号 class Acount5 { public static int money = 3000;// 静态变量，全局共享 // synchronized同步 // 重点：wait()，notify()，notifyAll()都要在同步锁中使用，否则报异常。 public void drawing(int m, Acount5 a) { synchronized (a) { String name = Thread.currentThread().getName();// 当前线程名称 // 首先判断当前线程是否是微信 if (name.equals("微信")) { // 如果是微信，那么微信线程先等待，进入阻塞状态 try { a.wait();// a对象是传过来的共享对象 } catch (InterruptedException e) { // TODO Auto-generated catch block e.printStackTrace(); } } // 取款金额超出余额，提示金额不足 if (money < m) { System.out.println(name + "操作，取款金额：" + m + ", 银行卡账号金额不足剩：" + money); } else { System.out.println(name + "操作，银行卡账号原有金额：" + money); System.out.println(name + "操作，取款金额：" + m); System.out.println(name + "取款操作: 银行卡原金额" + money + " - 取款金额：" + m); money -= m; System.out.println(name + "操作，取款后的银行卡余额：" + money); } // 因为一开始微信线程处于阻塞状态，而且支付宝线程已经在上面代码执行完，所以要唤醒处于阻塞中的微信线程 if (name.equals("支付宝")) { a.notify();// 唤醒微信线程继续执行 // a.notifyAll()也可以使用，这个方法是唤醒所有的阻塞线程。 } } } } class User5 implements Runnable { Acount5 acount;// 给用户一个账号属性 int money; // 消费金额 public User5() { } // 创建线程User类时就初始化一个账号和消费金额给用户 public User5(Acount5 acount, int money) { this.acount = acount; this.money = money; } @Override public void run() { acount.drawing(money, acount); } }
消费者和生产者模式
例子：生产者(Productor)将产品交给店员(Clerk)，而消费者(Customer)从店员处取走产品，店员一次只能持有固定数量的产品(比如:20），如果生产者试图生产更多的产品，店员会叫生产者停一下，如果店中有空位放产品了再通知生产者继续生产；如果店中没有产品了，店员会告诉消费者等一下，如果店中有产品了再通知消费者来取走产品。
这里可能出现两个问题：
生产者比消费者快时，消费者会漏掉一些数据没有取到。
消费者比生产者快时，消费者会取相同的数据。
例子代码如下：
/** * 生产者和消费者模式，注意下面为无限循环，建议调试模式看线程运行流程 * @author leak * */ public class Test11 { public static void main(String[] args) { Clerk c = new Clerk();//共享对象，产品数量 //匿名内部类，生产者 new Thread(new Runnable() { @Override public void run() { //同步锁传入共享对象 synchronized(c) { //获取线程名 String name = Thread.currentThread().getName(); while(true) { if(c.productNum==0) { System.out.println("产品数量为0，"+name+"开始生产"); while(c.productNum < 4) { c.productNum++; System.out.println("库存为："+c.productNum); } System.out.println("产品数为："+c.productNum+"，结束生产"); c.notify();//2产品生产结束，代表产品数已生产满，唤醒消费者线程，注意这里唤醒了消费者线程， //所以消费者线程处于就绪状态（但不会运行），因为现在生产者线程还在运行，继续循环进入下面的else语句， //然后执行wait()代表当前生产者线程进入阻塞状态释放对CPU的控制权，因为消费者处于就绪状态，所以消费者线程开始运行 }else { try { c.wait(); //1如果产品数量不为0，代表还有产品，所以生产者线程等待 } catch (InterruptedException e) { // TODO Auto-generated catch block e.printStackTrace(); } } } } }},"生产者").start(); //匿名内部类，消费者 new Thread(new Runnable() { @Override public void run() { //获取线程名 String name = Thread.currentThread().getName(); synchronized(c) { while(true) { //判断产品数量是否满了 if(c.productNum == 4) { System.out.println("产品数量为4，"+name+"开始消费"); while(c.productNum > 0) { c.productNum--; System.out.println("库存为："+c.productNum); } System.out.println("产品数为："+c.productNum+"，结束消费"); c.notify();//1产品消费结束，代表产品数已消费完，唤醒生产者线程， //因为上面的生产者现在进入了阻塞状态，现在唤醒生产者处于就绪状态，但是不会马上运行， //因为当前是消费者线程在运行，继续循环进入下面的else语句，执行wait()消费者进入阻塞状态 //消费者进入阻塞状态后，放弃对CPU的控制权，因为这里生产者已经被唤醒处于就绪状态，所以执行生产者线程 }else { try { c.wait(); //进入else这里，代表产品已经被消费完，所以消费者线程等待进入阻塞状态 } catch (InterruptedException e) { // TODO Auto-generated catch block e.printStackTrace(); } } } } }},"消费者").start(); } } class Clerk{ public static int productNum = 0;//店员持有商品数量 }
难点：估计在c.wait()和c.notify()那里，会分不清什么时候是消费者线程唤醒还是生产者线程唤醒/ 消费者和生产者进入等待，建议分别在两个匿名类里面的run()方法中，获取线程名/if语句/c.wait() 这三个地方打断点调试，看清楚线程运行情况，注意其中一个线程进入阻塞时，要手动切换到另外一个线程继续调试。
强调：c.wait()和c.notify()那里我注释写的很详细了，注意看。
如下图，手动切换线程继续调试。
如果不会调试的，建议先百度看完eclipse如何调试，还有注意代码的synchronized块，传递的是同一个共享对象c，所以两个线程才能共享产品数量。
