多线程
1 多线程
1.1 什么是进程？什么是线程？
进程是一个应用程序。（一个进程是一个软件）
线程是一个进程中的执行场景/执行单元。
一个进程可以启动多个线程。
1.2 对于java程序来说，当在DOS命令窗口中输入：
java HelloWorld 回车之后。
回先启动JVM，而JVM就是一个进程。
JVM在启动一个主线程调用main方法。
同时在启动一个垃圾回收线程负责看护，回收垃圾。
最起码，现在的java程序中至少有两个线程并发，一个是垃圾回收线程，一个是执行main方法的主线程。
1.3 进程和线程是什么关系？举个例子
阿里巴巴：进程
马云：阿里巴巴的一个线程。
童文红：阿里巴巴的一个线程。
京东：进程
强东：京东的一个线程。
妹妹：京东的一个线程。
进程可以看做是现实生当中的公司。
线程可以看做是公司当中的某个员工。
注意：
进程A和进程B的内存独立不共享。（阿里巴巴和京东资源不会共享的）
魔兽游戏是一个进程
酷狗音乐是一个进程
这两个进程是独立的，不共享资源。
线程A和线程B呢？
在java语言中：线程A和线程B，堆内存和方法区内存共享。
但是栈内存独立，一个线程一个栈。
假设启动10个线程，会有10个栈空间，每个栈和每个栈之间，互不干扰，各自执行各自的，这就是多线程并发。
火车站，可以看做是一个进程。
火车站中的每一个售票窗口可以看做是一个线程。
我在窗口1购票，你可以在窗口2购票，你不需要等我，我也不需要等你。
所以多线程并发可以提高效率。
java中之所以有多线程机制，目的就是为了提高程序的处理效率。
1.4 思考一个问题:
使用了多线程机制之后，main方法结束，是不是有可能程序也不会结束。
main方法结束之时主线程结束了，主栈空了，其它的栈（线程）可能还在压栈弹栈。
1.5 分析一个问题:对于单核的CPU来说，真的可以做到真正的多线程并发吗？
对于多核的CPU电脑来说，真正的多线程并发是没问题的。
4核CPU表示同一个时间点上，可以真正的有4个进程并发执行。
什么是真正的多线程并发？
t1线程执行t1的。
t2线程执行t2的。
t1不会影响t2，t2也不会影响t1。这叫做真正的多线程并发。
单核的CPU表示只有一个大脑：
不能够做到真正多线程并发，但是可以做到给人一种“多线程”并发的感觉。
对于单核的CPU来说，在某一个时间点上实际上只能处理一件事情，但是由于CPU的处理速度极快，多个线程之间频繁切换执行，
给人的感觉是：多个事情同时在做。
线程A：播放音乐。
线程B：运行魔兽游戏。
线程A和线程B频繁切换执行，人类会感觉音乐一直在播放，游戏一直在运行，给我们的感觉是同时并发的。
电影院采用胶卷播放电影，一个胶卷一个胶卷播放速度达到一定程度之后，人类的眼睛产生了错觉，感觉是动画的。
这说明人类的反应速度很慢，就像一根钢针扎到手上，到最终感觉到疼，这个过程是需要“很长的”时间的，在这个期间计算机可以进行亿万次的循环。
所以计算机的执行速度很快。
1.6 java语言中，实现线程有两种方式，哪两种方式呢？
第一种方式：编写一个类，直接机场java.lang.Thread，重写run方法。
// 定义线程类
public class MyThread exetends Thread{
public void run(){
}
}
// 创建线程对象
MyThread t = new MyThread();
// 启动线程
t.start();
第二种方式：编写一个类，实现java.lang.Runnable接口，实现run方法。
// 定义一个可运行的类
public class MyRunnable implements Runnable{
public void run(){
}
}
// 创建一个线程对象
Thread t = new Thread(new MyRunnable());
// 启动线程
t.start();
注意：第二种方式实现接口比较常用，因为一个类实现了接口，它还可以去继承其他的类，更灵活。
1.7 关于线程对象的生命周期
新建状态
就绪状态
运行状态
阻塞状态
死亡状态
1.8 （这部分内容属于了解）关于线程的调度
1.1 常见的线程调度模型有哪些？
抢占式调度模型：
哪个线程的优先级比较高，抢到的CPU时间片的概率就高一些/多一些。
java采用的就是抢占式调度模型。
均分是调度模型：
平均分配CPU时间片，每个线程占有的CPU时间片长度一样，平均分配，一切平等。
有一些编程语言，线程调度模型才用的是这种方式。
1.2 java中提供了哪些方法是和线程调度有关系的呢？
实例方法
void setPriority(int newPriority) 设置线程的优先级
int getPriority() 获取线程的优先级
最低优先级1
默认优先级是5
最高优先级是10
优先级比较高的获取CPU时间片可能会多一些。（但也不完全是，大概率是多的。）
静态方法
static void yield() 让位方法。
暂停当前正在执行的线程对象，并执行其他线程。
yield()方法不是祖册方法。让当前线程让位，让给其它线程使用。
yield()方法的执行会让当前线程从“运行状态”回到“就绪状态”。
实例方法：
void join()
合并线程
class MyThread1 extends Thread{
public void doSome(){
MyThread2 t = new MyThread2();
t.join();// 当前线程进入阻塞，t线程执行，直到t线程结束。当前线程才可以继续。
}
}
calss MyThread2 extends Thread{
}
2 关于多线程并发环境下，数据的安全问题。
2.1 为什么这个是重点？
以后在开发中，我们的项目都是运行在服务器当中，而服务器已经将线程的定义，线程对象的创建，线程的启动等，都已经实现完了。
这些代码我们都不需要编写。
最重要的事：你要知道，你编写的程序需要放到一个多线程的环境下运行，你更需要关注的是这些数据在多线程并发的环境下是否是安全的。（重点：*****）
2.2 什么时候数据在多线程并发的环境下会存在安全问题呢？
三个条件：
条件1：多线程并发。
条件2：有共享数据。
条件3：共享数据有修改的行为。
满足以上3个条件之后，就会存在线程安全问题。
2.3 怎么解决线程安全问题呢？
当多线程并发的环境下，有共享数据，并且这个数据还会被修改，此时就存在线程安全问题，怎么解决这个问题？
线程排队执行。（不能并发）
用排队执行解决线程安全问题。
这种机制被称为：线程同步机制。
专业术语叫做：线程同步，实际上就是线程不能并发了，线程必须排队执行。
怎么解决线程安全问题呀？
使用“线程同步机制”。
线程同步就是线程排队了，线程排队了就会牺牲一部分效率，没办法，数据安全第一位，
只有数据安全了，我们才可以谈效率。数据不安全，没有效率的事。
2.4 说到线程同步这块，涉及到这两个专业术语：
异步编程模型:
线程t1和线程t2，各自执行各自的，t1不管t2，t2不管t1，谁也不需要等谁，这种编程模型叫做：异步编程模型（效率较高）
异步就是并发。
同步编程模型：
线程t1和线程t2，在线程t1执行的时候，必须等待t2线程执行结束，或者说在t2线程执行的时候，必须等待t1线程执行结束，两个线程之间发生了等待关系，
这就是同步编程模型。效率较低，线程排队执行。
同步就是排队。
3 Java中有三大变量:[重要的内容]
实例变量： 在堆中
静态变量：在方法区
局部变量：在栈中
以上三大变量中：
局部变量永远都不会存在线程安全问题。
因为局部变量不共享。（一个线程一个栈）
局部变量在栈中，所以局部变量永远都不会共享。
实例变量在堆中，堆只有一个。
静态变量在方法区中，方法区只有一个。
堆和方法区都是多线程共享的，所以可能存在线程安全问题。
局部变量 + 常量：不会有线程安全问题。
成员变量：可能会有线程安全问题。
4 如果使用局部变量的话：
建议使用:StringBuilder
因为局部变量不存在线程安全问题。选择StringBuilder。
StringBuffer效率比较低。
ArrayList是非线程安全的。
Vector是线程安全的。
HashMap HashSet是非线程安全的。
HashTable是线程安全的。
5 总结
synchronized有两种写法：
第一种：同步代码块
灵活
synchronized（线程共享对象）{
同步代码块;
}
第二种：在实例方法上使用synchronized
表示共享对象一定是this
并且同步代码块是整个方法体。
第三种：在静态方法上使用synchronized
表示找类锁。
类锁永远只有1把。
就算创建了100个对象，那类锁也只有一把。
对象锁：1个对象1把锁，100个对象100把锁。
类锁：100个对象，也可能只是一把锁。
6 聊一聊，我们以后开发中应该子呢么解决线程安全问题？
是一上来就选择线程同步吗？synchronized
不是，synchronized会让程序的执行效率降低，用户体验不好。
系统的用户吞吐量降低。用户体验差。在不得已的情况下再选择线程同步机制。
第一种方案：尽量使用局部变量代替“实例变量和静态变量”。
第二种方案：如果必须是实例变量，那么可以考虑常见多个对象，这样实例变量内存就不共享了。（一个线程对应一个对象，100个线程对应100个对象。
对象不共享，就没有数据安全问题了。）
第三种：如果不能使用局部变量，对象也不能创建多个，这个时候只能选择synchronized了。线程同步机制。
7 线程这块还有哪些内容呢？列举一下：
7.1 守护线程
java语言中线程分为两大类：
一类是：用户线程。
一类是：守护线程（后台线程）
其中具有代表行的就是：垃圾回收线程（守护线程）。
守护线程的特点：
一般守护线程是一个死循环，所有的用户线程只要结束，守护线程自动结束。
注意：主线程main方法是一个用户线程。
守护线程用在什么地方呢？
每天00:00点的时候系统数据自动备份。
这个需要使用到定时器，并且我们可以将定时器设置为守护线程。
一直在那里看着，每到00:00的时候就备份一次。所有的用户线程如果结束了，守护线程自动退出，没有必要进行数据备份了。
7.2 定时器
定时器的作用：
间隔特定的时间，执行特定的程序。
每周要进行银行账户的总账操作。
每天要进行数据的备份操作。
在实际的开发汇总，没隔多久执行一段特定的程序，这种需求是很常见的，那么在java中其实可以采用多种睡眠方式实现：
可以使用sleep方法，睡眠，设置睡眠时间，每到这个时间醒来，执行任务，这种方式是最原始的定时器。（比较low）
在java的类库中已经写好了一个定时器：java.util.Timer，可以直接拿来用。
不过，这种方式在目前的开发中很少用，因为现在有很多高的框架都是支持定时任务的。
在实际的开发中，目前使用较多的是Spring框架中提供的SpringTask框架，这个框架只要进行简单地配置，
就可以完成定时器的任务。
7.3 实现线程的第三种方式：FutureTask方式，实现Callable接口。（JDK8新特性。）
这种方式实现的线程可以获取线程的返回值。
之前讲解的那两种方式是无法获取线程返回值的，因为run方法返回void。
思考：
系统委派一个线程去执行一个任务，该线程执行完任务之后，可能会有一个执行结果，我们怎么拿到这个执行结果呢？
使用第三种方式：实现Callable接口方式。
7.4 关于Object类中的wait和notify方法。（生产者和消费者模式。）
第一:wait和notify方法不是线程对象的方法，是java中任何一个java对象都有的方法，因为这两个方式是Object类中自带的。
wait方法和notify方法不是通过线程对象调用的，
不是这样的：t.wait(),也不是这样的：t.notify .. 不对。
第二：wait()方法作用？
Object o = new Object();
o.wait();
表示：让正在o对象上活的线程进入等待状态，无期限等待，直到被唤醒为止。
o.wait();方法的调用，会让“当前线程（正在o对象上活动的线程）”进入等待状态。
第三：notify()方法作用？
Object o = new Object();
o.nodify();
表示：
唤醒正在o对象上等待的线程。
还有一个nodifyAll()方法：
这个方法是唤醒o对象上处于等待的所有线程。
一个线程一个栈：
案例1的内存图：
案例2：线程的run内存图
案例2：线程的start内存图：
案例1 猜猜一下代码中有几个线程？？？：
package com.javaSe.Thread; /* 大家分析以下程序，有几个线程？除了垃圾回收线程之外。有几个线程？ 1个线程（因为程序只有一个栈） main begin m1 begin m2 begin m3 execute m2 end m1 end main end 一个栈中，自上而下的顺序依次逐行执行。 */ public class ThreadTest01 { public static void main(String[] args) { System.out.println("main begin"); m1(); System.out.println("main end"); } public static void m1(){ System.out.println("m1 begin"); m2(); System.out.println("m1 end"); } public static void m2(){ System.out.println("m2 begin"); m3(); System.out.println("m2 end"); } public static void m3(){ System.out.println("m3 execute"); } }
案例2 Thread线程：
package com.javaSe.Thread; /* 实现线程的第一种方式： 编写一个类，直接继承java.lang.Thread，重写run方法。 怎么创建线程对象？new就行了 怎么启动线程呢？调用线程对象的start()方法 注意： 亘古不变的道理： 方法体当中的代码永远都是自上而下的顺序依次逐行执行的。 以下程序的输出结果有这样的特点： 有先有后。 有多有少。 这是怎么回事呢？？？？ */ public class ThreadTest02 { public static void main(String[] args) { // 这里是main方法，这里的代码属于主线程，在主栈中运行。 // 新建一个分支线程对象。 MyThread t = new MyThread(); // 启动线程 // t.run();// 这样子做的话不会启动线程，不会分配新的分支栈。不能并发，也就是说他还是一个单线程，run方法中的程序走完了，main方法的程序才会继续执行。 // 启动线程 // start()方法的作用是：启动一个分支线程，在JVM中开辟一个新的栈空间，这段代码任务完成之后，瞬间就结束了。 // 这段代码的任务只是为了开启一个新的栈空间，只要新的栈空间开出来，start()方法就结束了，线程就启动成功了。 // 启动成功的线程会自动调用run()方法，并且run方法在分支栈的站底部（压栈）。 // run方法在分支栈的站底部，main方法在主栈的栈底部。run和main是平级的。 t.start(); // 这里的代码还是运行在主线程中 for (int i = 0; i < 100; i++) { System.out.println("主线程--->" + i); } } } class MyThread extends Thread{ @Override public void run() { // 编写程序，这段程序运行在分支线程中（分支栈）。 for(int i = 0; i < 1000; i++){ System.out.println("分支线程--->" + i); } } }
案例3 实现Runnable线程接口：
package com.javaSe.Thread; /* 实现线程的第二种方式：编写一个类实现java.lang.Runnable接口。 */ public class ThreadTest03 { public static void main(String[] args) { /* // 创建一个可运行对象 MyRunnable r = new MyRunnable(); // 将可运行的对象封装成一个线程对象 Thread t = new Thread(r);*/ // 将上面两行代码合并成一行 Thread t = new Thread(new MyRunnable()); // 启动线程 t.start(); // 这里的代码还是运行在主线程中 for (int i = 0; i < 100; i++) { System.out.println("主线程--->" + i); } } } // 这并不是一个线程类，是一个可运行的类，他还不是一个线程。 class MyRunnable implements Runnable{ @Override public void run() { // 编写程序，这段程序运行在分支线程中（分支栈）。 for(int i = 0; i < 1000; i++){ System.out.println("分支线程--->" + i); } } }
案例4 利用匿名内部类实现线程：
package com.javaSe.Thread; /* 采用匿名内部类可以吗？ */ public class ThreadTest04 { public static void main(String[] args) { // 创建线程对象，采用匿名内部类方式。 Thread t = new Thread(new Runnable() { @Override public void run() { for (int i = 0; i < 100; i++) { System.out.println("分支线程---> " + i); } } }); t.start(); for (int i = 0; i < 100; i++) { System.out.println("主线程---> " + i); } } }
案例5获取线程的名字：
package com.javaSe.Thread; /* 1 怎么获取当前线程对象 2 获取线程对象的名字 String name = 线程对象.getName(); 3 修改线程对象的名字 线程对象.setName("tttt"); 4 当线程没有设置名字的时候，默认的名字有什么规律？（了解一下） Thread-0 Thread-1 Thread-2 Thread-3 ... */ public class ThreadTest05 { public static void main(String[] args) { // 创建线程对象 MyThread2 mt = new MyThread2(); // 设置线程的名字 mt.setName("t1"); // 获取线程的名字 String mtName = mt.getName(); // 如果没有设置线程的名字 默认为：Thread-0 System.out.println(mtName); // 在新建一个线程 MyThread2 mt2 = new MyThread2(); mt2.setName("t2"); String mt2Name = mt2.getName(); System.out.println(mt2Name); // Thread-1 // 启动线程。 mt.start(); } } class MyThread2 extends Thread { public void run(){ for (int i = 0; i < 100; i++) { System.out.println("分支线程--->" + i); } } }
案例6：关于线程的sleep方法
package com.javaSe.Thread; /* 关于线程的sleep方法： static void sleep(long millis) 1 静态方法 2 参数是毫秒 3 作用：让当前线程进入休眠装填，进入阻塞状态，放弃占有的CPU时间片，让给其它线程使用。 这行代码出现在A线程中，A线程就进行休眠。 这行代码出现在B线程中，B线程就进行休眠。 4 Thread.sleep()方法，可以做到这种效果： 间隔特定的时间，去执行一段特定的代码，每隔多久执行一次。 */ public class ThreadTest06 { public static void main(String[] args) { /*try { // 让当前线程进入休眠，睡眠5秒钟。 // 当前线程是主线程。 Thread.sleep(1000 * 5); } catch (InterruptedException e) { e.printStackTrace(); } System.out.println("Hello World!");*/ for (int i = 0; i < 10; i++) { System.out.println(Thread.currentThread().getName() + "--->" + i); try { // 睡眠1秒 Thread.sleep(1000); } catch (InterruptedException e) { e.printStackTrace(); } } } }
案例7：关于sleep线程方法的面试题：
package com.javaSe.Thread; /* 关于线程的sleep方法： static void sleep(long millis) 1 静态方法 2 参数是毫秒 3 作用：让当前线程进入休眠装填，进入阻塞状态，放弃占有的CPU时间片，让给其它线程使用。 这行代码出现在A线程中，A线程就进行休眠。 这行代码出现在B线程中，B线程就进行休眠。 4 Thread.sleep()方法，可以做到这种效果： 间隔特定的时间，去执行一段特定的代码，每隔多久执行一次。 */ public class ThreadTest06 { public static void main(String[] args) { /*try { // 让当前线程进入休眠，睡眠5秒钟。 // 当前线程是主线程。 Thread.sleep(1000 * 5); } catch (InterruptedException e) { e.printStackTrace(); } System.out.println("Hello World!");*/ for (int i = 0; i < 10; i++) { System.out.println(Thread.currentThread().getName() + "--->" + i); try { // 睡眠1秒 Thread.sleep(1000); } catch (InterruptedException e) { e.printStackTrace(); } } } }
案例8 如何让正在睡眠的线程执行：
package com.javaSe.Thread; /* sleep睡眠太久了，如果希望半道上醒来，你应该怎么办？也就是说怎么唤醒正在睡眠的线程。 注意:这个不是终断线程的执行，是终止线程的睡眠。 */ public class TheadTest08 { public static void main(String[] args) { // 创建线程对象 Thread t = new Thread(new MyRunnable2()); // 更改线程名称 t.setName("t"); // 启动线程 t.start(); // 希望5秒之后，t线程醒来(5秒之后主线程手里的活干完了) try { Thread.sleep(1000 * 5); } catch (InterruptedException e) { // 打印异常信息 e.printStackTrace(); } // 终断t线程的睡眠（这段终断睡眠的方法依靠了java的异常处理机制。） t.interrupt();// 干扰，一盆冷水过去！ } } class MyRunnable2 implements Runnable{ @Override public void run() { System.out.println(Thread.currentThread().getName() + "---> begin"); try { // 睡眠1年，1年之后才可以醒来。 // 这里只能try/catch不能throws是因为什么呢？ // 因为run()方法在父类中没有抛出任何异常，子类不能比父类抛出更多的异常。 Thread.sleep(1000 * 60 * 60 * 24 * 365); } catch (InterruptedException e) { e.printStackTrace(); } // 1年之后才会执行这里。 System.out.println(Thread.currentThread().getName() + "---> end"); // 调用doOther /*try { doOther(); } catch (Exception e) { e.printStackTrace(); }*/ } // 这个是可以的，你可以在其他方法进行throws，但是在run()方法中还是只可以进行try/catch】 /*public void doOther() throws Exception{ }*/ }
案例9 怎么强行终止一个线程（此方法现已不可以用，下面的案例才是最完美的）：
package com.javaSe.Thread; /* 在java中怎么强行终止一个线程的执行。 这种方式存在很大的缺点：容易丢失数据，因为这种方式是直接将线程杀死了。 线程没有保存的数据将会丢失。不建议使用。 */ public class ThreadTest09 { public static void main(String[] args) { Thread t = new Thread(new MyRunnable3()); t.setName("t"); t.start(); // 模拟五秒钟 try { Thread.sleep(1000 * 5); } catch (InterruptedException e) { e.printStackTrace(); } // 5秒之后强行终止t线程 t.stop();// 已过时（不建议使用） } } class MyRunnable3 implements Runnable{ @Override public void run() { for (int i = 0; i < 10; i++) { System.out.println(Thread.currentThread().getName() + "--->" + i); try { Thread.sleep(1000); } catch (InterruptedException e) { e.printStackTrace(); } } } }
案例10 如何合理的终止一个线程：
package com.javaSe.Thread; /* 怎么合理的终止一个线程的执行，这种方式很常用的： */ public class ThreadTest10 { public static void main(String[] args) { MyRunnable4 r = new MyRunnable4(); Thread t = new Thread(r); t.setName("t"); t.start(); // 模拟5秒 try { t.sleep(1000 * 5); } catch (InterruptedException e) { e.printStackTrace(); } // 终止线程 // 你想要什么时候终止t的执行,那么你把标记修改成false,就结束了。 r.run = false; } } class MyRunnable4 implements Runnable{ // 打一个布尔标记。 boolean run = true; @Override public void run() { for (int i = 0; i < 10; i++) { if (run){ System.out.println(Thread.currentThread().getName() + "--->" + i); try { Thread.sleep(1000); } catch (InterruptedException e) { e.printStackTrace(); } } else { // return就结束了，你在结束之前还有什么没有保存的 // 在这里进行保存就可以了 save... // 终止当前线程 return; } } } }
案例11 如何获取线程的优先级：
package com.javaSe.Thread; public class ThreadTest11 { public static void main(String[] args) { /*System.out.println("最高优先级 = " + Thread.MAX_PRIORITY); System.out.println("最低优先级 = " + Thread.MIN_PRIORITY); System.out.println("默认优先级 = " + Thread.NORM_PRIORITY);*/ // 获取当前线程对象，获取当前线程的优先级 Thread currentThread = Thread.currentThread(); // 设置主线程的优先级1 currentThread.currentThread().setPriority(1); // main线程的默认优先级是5 // System.out.println(currentThread.getName() + "线程的默认优先级是" + currentThread.getPriority()); /*int priority = currentThread.getPriority(); System.out.println("当前对象线程优先级为 = " + priority);*/ Thread thread = new Thread(new MyRunnable5()); thread.setPriority(10); thread.setName("run"); thread.start(); // 优先级较高的，只是抢到的CPU时间片相对多一些。 // 大概率方向更偏向于优先级比较高的。 for (int i = 0; i < 10000; i++) { System.out.println(Thread.currentThread().getName() + "--->" + i); } } } class MyRunnable5 implements Runnable{ @Override public void run() { // 获取线程优先级 // System.out.println(Thread.currentThread().getName() + "线程的默认优先级" + Thread.currentThread().getPriority()); for (int i = 0; i < 10000; i++) { System.out.println(Thread.currentThread().getName() + "--->" + i); } } }
案例12 让位，当前线程暂停，回到就绪状态，让给其它线程
package com.javaSe.Thread; /* 让位，当前线程暂停，回到就绪状态，让给其它线程。 静态方法：Thread.yield(); */ public class ThreadTest12 { public static void main(String[] args) { Thread t = new Thread(new MyRunnable6()); t.setName("t"); t.start(); for (int i = 1; i <= 10000; i++) { System.out.println(Thread.currentThread().getName() + "--->" + i); } } } class MyRunnable6 implements Runnable{ @Override public void run() { for (int i = 1; i <= 10000; i++) { // 每100个让位1次 if (i % 100 == 0){ Thread.yield(); // 当前线程暂停一下，让给主线程。 } System.out.println(Thread.currentThread().getName() + "--->" + i); } } }
案例13 线程合并：
package com.javaSe.Thread; /* 线程合并 */ public class ThreadTest13 { public static void main(String[] args) { System.out.println("main begin"); Thread t = new Thread(new MyRunnable7()); t.setName("t"); t.start(); // 合并线程 try { t.join(); // t合并到当前线程中，当前线程受到阻塞，t线程执行直到结束。 } catch (InterruptedException e) { e.printStackTrace(); } System.out.println("main end"); } } class MyRunnable7 implements Runnable{ @Override public void run() { for (int i = 0; i < 10000; i++) { System.out.println(Thread.currentThread().getName() + "--->" + i); } } }
多线程并发对同一个账户进行取款
1 错误的多线程案例 如果线程并发，不进行排队，那么当两个线程操作同一个对象，就会出现问题：
银行账户类：
package com.javaSe.threadsafe; /* 银行账户 使用线程同步机制，解决线程安全问题。 */ public class Account { // 账户 private String actno; // 余额 private double balance; // 实例变量 // 对象 Object obj = new Object(); // 实例变量（Account对象是多线程共享的，Account对象中的实例变量obj也是共享的。） public Account() { } public Account(String actno, double balance) { this.actno = actno; this.balance = balance; } public String getActno() { return actno; } public void setActno(String actno) { this.actno = actno; } public double getBalance() { return balance; } public void setBalance(double balance) { this.balance = balance; } // 取款的方法 public void withdraw(double money){ double before = this.getBalance(); // 10000 double after = before - money; try { Thread.sleep(1000); } catch (InterruptedException e) { e.printStackTrace(); } this.setBalance(after); } }
账户线程类：
package com.javaSe.threadsafe; public class AccountThread extends Thread { // 两个线程必须共享同一个账户对象。 private Account act; // 通过构造方法传递过来账户对象 public AccountThread(Account act){ this.act = act; } public void run(){ // run方法的执行表示取款操作 // 假设取款5000 double money = 5000; // 取款 act.withdraw(money); System.out.println(Thread.currentThread().getName() + "对" + act.getActno() + "取款"+ money +"成功，余额 = " + act.getBalance()); } }
测试类：
package com.javaSe.threadsafe; public class Test { public static void main(String[] args) { // 创建账户对象（只创建一个） Account act = new Account("A-001",10000); // 创建两个线程对象 Thread t1 = new AccountThread(act); Thread t2 = new AccountThread(act); // 设置name t1.setName("t1"); t2.setName("t2"); // 启动线程取款 t1.start(); t2.start(); } }
2 使用线程同步机制，解决线程安全问题：
银行账户类：
package com.javaSe.threadsafe2; /* 银行账户 使用线程同步机制，解决线程安全问题。 */ public class Account { // 账户 private String actno; // 余额 private double balance; // 实例变量 // 对象 Object obj = new Object(); // 实例变量（Account对象是多线程共享的，Account对象中的实例变量obj也是共享的。） public Account() { } public Account(String actno, double balance) { this.actno = actno; this.balance = balance; } public String getActno() { return actno; } public void setActno(String actno) { this.actno = actno; } public double getBalance() { return balance; } public void setBalance(double balance) { this.balance = balance; } // 取款的方法 public void withdraw(double money){ // 以下这几行代码必须是线程排队的，不能并发。 // 一个线程把这里的代码全部执行结束之后，另一个线程才能进来。 /* 线程同步机制的语法是： synchronized (){ // 线程同步代码块。 } synchronized后面的小括号中传的这个“数据”是相当关键的。 这个数据必须是多线程共享的数据，才能达到多线程排队。 ()中写什么? 那要看你想让哪些线程同步。 假设t1 t2 t3 t4 t5，有五个线程 你只希望t1 t2 t3排队，t4 t5 不需要排队怎么办？ 你一定要在()中写一个t1 t2 t3共享的对象。而这个对象对于t4 t5来说不是共享的。 这里的共享对象：账户对象 账户对象是共享的吗，那么这里this就是账户对象吧 不一定是this，这里只要是多线程共享的那个对象就行。 在java语言中，任何一个对象都有“一把锁”，其实这把锁就是标记。（只是把它叫做锁） 100个对象，100把锁。1个对象1把锁 以下代码的执行原理？ 1 假设t1和t2线程并发，开始执行以下代码的时候，肯定有一个先一个后。 2 假设t1先执行了，遇到了synchronized 这个时候会自动找“后面共享对象”的对象锁，找到之后并占有这把锁，然后执行同步代码块中的程序， 在程序执行过程中一直都是占有者把锁的。知道同步代码块代码结束，这把锁才会释放。 3 假设t1已经占有了这把锁，t2也遇到了synchronized关键字，也会去占有后面共享对象的这把锁，结果这把锁被t1占有，t2只能在同步代码块的外面等待t1的结束， 直到t1把同步代码块执行结束了，t1也会归还这把锁，此时t2终于等到这把锁，然后t2占有这这把锁之后，进入同步代码块中执行代码。 这样就达到了线程排队执行。 这里需要注意的事：这个共享对象一定要选好了。这个共享对象一定是你需要排队执行的这些线程对象所共享的。 */ // Object obj2 = new Object(); // Object o = null; // synchronized (o) { // java.lang.NullPointerException // synchronized (obj2) { // 这样编写就不安全了，因为obj2是一个局部变量，他不是共享对象，第一个线程对象进来的时候会new一个obj对象，第二个线程进来还是会new一个，那就是多个了 // synchronized (obj) { // 这样也行 // synchronized (this) { // 这种才是最好的 // synchronized ("abc") { // "abc"在字符串常量池当中，只有一个 但是这样的话 所有的线程都需要进行等待，这样不行。 double before = this.getBalance(); // 10000 double after = before - money; try { Thread.sleep(1000); } catch (InterruptedException e) { e.printStackTrace(); } this.setBalance(after); // } } }
账户线程类：
package com.javaSe.threadsafe2; public class AccountThread extends Thread { // 两个线程必须共享同一个账户对象。 private Account act; // 通过构造方法传递过来账户对象 public AccountThread(Account act){ this.act = act; } public void run(){ // run方法的执行表示取款操作 // 假设取款5000 double money = 5000; // 取款 // synchronized (this){ // 这样不行，因为这个是线程对象，你new了两个线程对象，他就是两个内存地址，不存在线程共享。 synchronized (act){ act.withdraw(money); // 这种方式也可以，只不过你扩大了同步的范围，效率更低了。 } System.out.println(Thread.currentThread().getName() + "对" + act.getActno() + "取款"+ money +"成功，余额 = " + act.getBalance()); } }
测试类：
package com.javaSe.threadsafe2; public class Test { public static void main(String[] args) { // 创建账户对象（只创建一个） Account act = new Account("A-001",10000); // 创建两个线程对象 Thread t1 = new AccountThread(act); Thread t2 = new AccountThread(act); // 设置name t1.setName("t1"); t2.setName("t2"); // 启动线程取款 t1.start(); t2.start(); } }
实例方法应用锁类：
银行账户类：
package com.javaSe.threadsafe3; public class Account { // 账户 private String actno; // 余额 private double balance; // 实例变量 // 对象 Object obj = new Object(); // 实例变量（Account对象是多线程共享的，Account对象中的实例变量obj也是共享的。） public Account() { } public Account(String actno, double balance) { this.actno = actno; this.balance = balance; } public String getActno() { return actno; } public void setActno(String actno) { this.actno = actno; } public double getBalance() { return balance; } public void setBalance(double balance) { this.balance = balance; } // 取款的方法 /* 在实例方法上可以使用synchronized吗？可以的。 synchronized出现在实例方法上，一定锁的是this。 没得挑。只能是this。不能是其它的对象了。 所以这种方式不灵活哦 另外还有一个缺点：synchronized 出现在实例方法上 表示这个方法体都需要同步，可能会无故扩大同步的范围，导致程序的执行效率较低。 所以这种方式不常用。 synchronized使用在实例方法上有什么优点？ 代码写的少了。节俭了。 如果共享的对象就是this，并且需要同步的代码块是整个方法体，建议使用这种方式。 */ public synchronized void withdraw(double money){ double before = this.getBalance(); // 10000 double after = before - money; try { Thread.sleep(1000); } catch (InterruptedException e) { e.printStackTrace(); } this.setBalance(after); } }
账户线程类：
package com.javaSe.threadsafe3; public class AccountThread extends Thread { // 两个线程必须共享同一个账户对象。 private Account act; // 通过构造方法传递过来账户对象 public AccountThread(Account act){ this.act = act; } public void run(){ // run方法的执行表示取款操作 // 假设取款5000 double money = 5000; // 取款 act.withdraw(money); // 这种方式也可以，只不过你扩大了同步的范围，效率更低了。 System.out.println(Thread.currentThread().getName() + "对" + act.getActno() + "取款"+ money +"成功，余额 = " + act.getBalance()); } }
测试类：
package com.javaSe.threadsafe3; public class Test { public static void main(String[] args) { // 创建账户对象（只创建一个） Account act = new Account("A-001",10000); // 创建两个线程对象 Thread t1 = new AccountThread(act); Thread t2 = new AccountThread(act); // 设置name t1.setName("t1"); t2.setName("t2"); // 启动线程取款 t1.start(); t2.start(); } }
