一文搞懂Java多线程
文章目录
一、基本概念：程序、进程、线程
要了解线程，首先得先了解程序和进程
-
程序（program）是为完成特定任务、用某种语言编写的一组指令的集合。
-
进程（process）是程序的一次执行过程，或者是正在运行的一个程序，是一个动态的过程：有他自身的产生、存在和消亡的过程（生命周期）
》如：运行中的QQ，运行中的MP3播放器
》程序是静态的，进程是动态的
》进程作为资源分配的单位，系统在运行时会为每个进程分配不同的内存区域 -
线程（thread），进程可进一步细化为线程，是一个程序内部的一条执行路径
》若一个进程同一时间并行执行多个线程，就是支持多线程的
》线程作为调度和执行的单位，每个线程拥有独立的运行栈和程序计数器（pc），线程切换的开销小
》一个进程中的多个线程共享相同的内存单元/内存地址空间→他们从同一堆中分配对象，可以访问相同的变量和对象，这就使得线程间通信更简洁、高效。但多个线程操作共享的系统资源可能就会带来安全的隐患 -
单核CPU和多核CPU的理解
》单核CPU，其实是一种假的多线程，因为在一个时间单元内，也只能执行一个线程的任务。例如：虽然有很对车道，但是收费站只有一个工作人员在收费，只有收了费才能通过，那么CPU就好比收费人员，如果有人不想交钱，那么收费人员就可以把它“挂起”（晾着他，等他想通了，准备好了钱，再去收费）。但是因为CPU时间单元特别短，所以感觉不出来
》如果是多核的话，才能更好的发挥多线程的效率（现在的服务器都是多核的）
》一个Java应用程序java.exe，其实至少有3个线程：main()主程序，gc()垃圾回收线程，异常处理线程。当然如果发生异常，会影响主线程 -
并行与并发
》并行：多个CPU同时执行多个任务。比如：多个人同时做不同的事
》并发：一个CPU（采用时间片）同时执行多个任务。比如：秒杀、多个人做同一件事 -
使用多线程的优点
》背景：以单核CPU为例，只使用单个线程先后完成多个任务（调用多个方法），肯定比用多个线程来完成用的时间更短，为何仍需多线程呢？
》提高应用程序的响应。对图形化界面更有意义，可增强用户体验
》提高计算机系统CPU的利用率
》改善程序结构，将既长又复杂的进程分为多个线程，独立运行，利于理解和修改 -
何时需要多线程
》程序需要同时执行两个或多个任务
》程序需要实现一些等待的任务，如用户输入、文本读写操作、网络操作、搜索等
》需要一些后台运行的程序时
二、线程的创建和使用
多线程的创建
方式一：继承于Thread类
- 创建一个继承于Thread类的子类
- 重写Thread类的run()→将此线程执行的操作重写在run()中
- 创建Thread类的子类对象
- 通过此对象调用start()：
》start()作用：①启动当前线程②调用当前线程的run()
》注意事项：①不能在没有调用start()的情况下，直接run()启动线程
②不能调用了一次start()之后，再去调用start()，如有需要，再去new一个对象
例子：遍历100以内所有的偶数
//1. 创建一个继承于Thread类的子类
class MyThread extends Thread {
//2. 重写Thread类的run()→将此线程执行的操作重写在run()中
@Override
public void run(){
for (int i = 0; i < 100; i++) {
if(i % 2 == 0){
System.out.println(i);
}
}
}
}
public class ThreadTest {
public static void main(String[] args) {
//3. 创建Thread类的子类对象
MyThread t1 = new MyThread();
//4. 通过此对象调用start()：
//start()作用①启动当前线程②调用当前线程的run()
t1.start();
//如下操作仍在main线程中执行
System.out.println("hello world");
}
}
此多线程的工作原理如下：（字有点丑）
改进：
既然创建的MyThread的对象只用过一次，后面就没有用了，那就可以用匿名的方式——创建Thread 的匿名子类
new MyThread(){
@Override
public void run(){
for (int i = 0; i < 100; i++) {
if(i % 2 == 0){
System.out.println(i);
}
}
}
}.start();
完整代码如下：
//1. 创建一个继承于Thread类的子类
class MyThread extends Thread {
//2. 重写Thread类的run()→将此线程执行的操作重写在run()中
@Override
public void run(){
for (int i = 0; i < 100; i++) {
if(i % 2 == 0){
System.out.println(i);
}
}
}
}
public class ThreadTest {
public static void main(String[] args) {
// //3. 创建Thread类的子类对象
// MyThread t1 = new MyThread();
//
// //4. 通过此对象调用start()
// t1.start();
new MyThread(){
@Override
public void run(){
for (int i = 0; i < 100; i++) {
if(i % 2 == 0){
System.out.println(i);
}
}
}
}.start();
System.out.println("hello world");
}
}
Thread的常用方法
线程的优先级
例2：创建3个窗口卖票，总票数为100张（继承Thread方式）
class Window extends Thread{
private int ticket = 100;
@Override
public void run() {
while(true){
if (ticket>0){
System.out.println(getName()+":卖票，票号为："+ticket);
ticket--;
}else{
break;
}
}
}
}
public class WindowTest {
public static void main(String[] args) {
Window t1 = new Window();
Window t2 = new Window();
Window t3 = new Window();
t1.setName("窗口1");
t2.setName("窗口2");
t3.setName("窗口3");
t1.start();
t2.start();
t3.start();
}
}
此时输出为：
注意此时的程序是每个窗口各卖100张票，总和为300张了，这不对。 只需做出小修改，将ticket加一个static即可。
private static int ticket = 100;
输出结果：
可以看到，除了100以外（之后会讲解决线程的安全问题，这里先忽略），其他票号都是只出现了一次
方式二：实现Runnable接口
- 创建一个实现了Runnable接口的类
- 实现类去实现Runnable中的抽象方法：run()
- 创建实现类的对象
- 将此对象作为参数传递到Thread类的构造器中，创建Thread类的对象
- 通过Thread类的对象调用start()：①启动线程②调用当前线程的run()→调用了Runnable类型的target的run()
例子：遍历100以内所有的偶数
// 1. 创建一个实现了Runnable接口的类
class MThread implements Runnable{
//2. 实现类去实现Runnable中的抽象方法：run()
@Override
public void run() {
for (int i = 0; i <100 ; i++) {
if(i % 2 == 0){
System.out.println(Thread.currentThread().getName()+":"+i);
}
}
}
}
public class ThreadTest1 {
public static void main(String[] args) {
//3. 创建实现类的对象
MThread mThread = new MThread();
//4. 将此对象作为参数传递到Thread类的构造器中，创建Thread类的对象
Thread t1 = new Thread(mThread);
t1.setName("线程1");
//5. 通过Thread类的对象调用start()：
// ①启动线程②调用当前线程的run()→调用了Runnable类型的target的run()
t1.start();
//再启动一个线程，遍历100以内的偶数
Thread t2 = new Thread(mThread);
t2.setName("线程2");
t2.start();
}
}
输出结果：
例2：创建3个窗口卖票，总票数为100张（实现Runnable接口的方式）
class Window1 implements Runnable{
private int ticket = 100;
@Override
public void run() {
while(true){
if (ticket>0){
System.out.println(Thread.currentThread().getName()+":卖票，票号为："+ticket);
ticket--;
}
else{
break;
}
}
}
}
public class WindowTest1 {
public static void main(String[] args) {
Window1 w = new Window1();
Thread t1 = new Thread(w);
Thread t2 = new Thread(w);
Thread t3 = new Thread(w);
t1.setName("窗口1");
t2.setName("窗口2");
t3.setName("窗口3");
t1.start();
t2.start();
t3.start();
}
}
结果如下：
可以看到，ticket并没有加static，为什么就可以实现3个窗口卖100张票呢？——因为我们只造了一个对象，这一个对象放到3个构造器中，说明这3个线程都是用的同一个new的window，所以ticket自然就是同一个ticket
比较创建线程的两种方式：
开发中，优先选择Runnable接口的方式
原因：
①实现的方式没有类的单继承的局限性，例如3个窗口卖票的例子，Window继承了Thread之后，就没法再继承其他类了（在Java中，继承可是稀缺资源）
②实现的方式更适合来处理多个线程有共享数据的情况
联系：public class Thread implements Runnable
相同点：两种方式都需要重写run()，将线程要执行的逻辑声明在run()中。
方式三：实现Callable接口
步骤：
- 创建一个实现Callable的实现类
- 实现call方法，将此线程需要执行的操作声明在call()中
- 创建Callable接口实现类的对象
- 将此Callable接口实现类的对象作为传递到FutureTask构造器中，创建FutureTask的对象
- 将FutureTask的对象作为参数传递到Thread类的构造器中，创建Thread对象，并调用start()
- 如有需要，返回Callable中call方法的返回值
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;
//1.创建一个实现Callable的实现类
class NumThread implements Callable{
//2.实现call方法，将此线程需要执行的操作声明在call()中
@Override
public Object call() throws Exception {
int sum = 0;
for (int i = 1; i <=100 ; i++) {
if(i%2==0){
System.out.println(i);
sum += i;
}
}
return sum;
}
}
public class ThreadNew {
public static void main(String[] args) {
//3.创建Callable接口实现类的对象
NumThread numThread = new NumThread();
//4.将此Callable接口实现类的对象作为传递到FutureTask构造器中，创建FutureTask的对象
FutureTask futureTask = new FutureTask(numThread);
//5.将FutureTask的对象作为参数传递到Thread类的构造器中，创建Thread对象，并调用start()
new Thread(futureTask).start();
try {
//6.如有需要，返回Callable中call方法的返回值
//get()返回值即为FutureTask构造器参数Callable实现类重写的call()的返回值
Object sum = futureTask.get();
System.out.println("总和为："+sum);
} catch (InterruptedException e) {
e.printStackTrace();
} catch (ExecutionException e) {
e.printStackTrace();
}
}
}
如何理解实现Callable接口的方式创建多线程比实现Runnable接口创建多线程方式强大？
- call()可以有返回值
- call()可以抛出异常，被外面的操作捕获，获取异常信息
- Callable是支持泛型的
方式四：使用线程池
步骤：
- 提供指定线程数量的线程池
- 执行指定线程的操作，需要提供实现Runnable接口（或Callable接口）实现类的对象
- 关闭连接池
import java.util.concurrent.Executor;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
class NumberThread implements Runnable{
@Override
public void run() {
for (int i = 0; i < 100; i++) {
if (i%2==0){
System.out.println(Thread.currentThread().getName()+":"+i);
}
}
}
}
class NumberThread1 implements Runnable{
@Override
public void run() {
for (int i = 0; i < 100; i++) {
if (i%2!=0){
System.out.println(Thread.currentThread().getName()+":"+i);
}
}
}
}
public class ThreadPool {
public static void main(String[] args) {
//1.提供指定线程数量的线程池
ExecutorService service = Executors.newFixedThreadPool(10);
//2.执行指定线程的操作，需要提供实现Runnable接口（或Callable接口）实现类的对象
service.execute(new NumberThread());//适合适用于Runnable
service.execute(new NumberThread1());
// service.submit(Callable callable);//适合适用于Callable
//3.关闭连接池
service.shutdown();
}
}
三、线程的生命周期
四、线程的同步
为什么要进行线程的同步呢？——①多个线程执行的不确定性引起执行结果的不稳定 ②多个线程对数据的共享，会造成操作的不完整性，会破坏数据
举个例子：假如一个账户有3000元，我去取2000元，恰巧就在我输完账户密码等待系统响应的时候，我媳妇也输完账户密码，媳妇她也取2000元，那这个时候系统就会出现问题了，是给我和媳妇各自都吐出2000元吗？还是显示出错呢？
这就是线程的安全问题，那么要怎么解决这种线程的安全问题呢？——线程的同步
还是举卖票的例子：创建三个窗口卖票，总票数为100张
- 问题：卖票过程中，出现了重票、错票——出现了线程安全的问题
- 问题出现的原因：当某个线程操作车票的过程中，尚未操作完成时，其他线程参与进来，也操作车票
- 如何解决：当一个线程a在操作ticket的时候，其他线程不能参与进来（相当于上了把锁），直到线程a操作完ticket时，其他线程才可以开始操作ticket，这种情况即使线程a出现了阻塞，也不能改变
- 在Java中，我们通过同步机制，来解决线程安全问题
- 局限性：操作同步代码时，只能有一个线程参与，其他线程等待，相当于是一个单线程的过程，效率低
方式一：同步代码块
synchronized(同步监视器){
//需要同步的代码
}
说明：
①操作共享数据的代码，即为需要被同步的代码
②共享数据：多个线程共同操作的变量，比如：ticket就是共享数据
③同步监视器，俗称：锁。任何类的对象都可以来充当锁
要求：多个线程必须共用同一把锁
使用实现Runnable接口的方式
可以看到没进行同步的代码为：
class Window1 implements Runnable{
private int ticket = 100;
@Override
public void run() {
while(true){
if (ticket>0){
try{
Thread.sleep(100);
}catch (InterruptedException e){
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName()+":卖票，票号为："+ticket);
ticket--;
}
else{
break;
}
}
}
}
public class WindowTest1 {
public static void main(String[] args) {
Window1 w = new Window1();
Thread t1 = new Thread(w);
Thread t2 = new Thread(w);
Thread t3 = new Thread(w);
t1.setName("窗口1");
t2.setName("窗口2");
t3.setName("窗口3");
t1.start();
t2.start();
t3.start();
}
}
运行结果为：可以看出是有错票和重票的
这里再加上synchronized ，并且以obj为锁
class Window1 implements Runnable{
Object obj = new Object();
private int ticket = 100;
@Override
public void run() {
while(true){
synchronized (obj){
if (ticket>0){
try{
Thread.sleep(100);
}catch (InterruptedException e){
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName()+":卖票，票号为："+ticket);
ticket--;
}
else{
break;
}
}
}
}
}
public class WindowTest1 {
public static void main(String[] args) {
Window1 w = new Window1();
Thread t1 = new Thread(w);
Thread t2 = new Thread(w);
Thread t3 = new Thread(w);
t1.setName("窗口1");
t2.setName("窗口2");
t3.setName("窗口3");
t1.start();
t2.start();
t3.start();
}
}
输出结果如下，可以看到已经消除了错票和重票
改进：改进：这时候想，每次都需要再去new一个对象来做锁吗 ？有没有什么简单的对象可用 只要保证唯一就行——当前对象this
synchronized (this)
因为调用run()方法的对象是this，而方式是在Window1中定义的，所以Window1的对象就是this，我们自始至终只造过一个Window1对象w，所以this是唯一的
使用继承Thread类的方式：
可以看到没进行同步的代码为：
class Window extends Thread{
Object obj = new Object();
private static int ticket = 100;
@Override
public void run() {
while(true){
if (ticket>0){
try{
Thread.sleep(100);
}catch (InterruptedException e){
e.printStackTrace();
}
System.out.println(getName()+":卖票，票号为："+ticket);
ticket--;
}else{
break;
}
}
}
}
public class WindowTest {
public static void main(String[] args) {
Window t1 = new Window();
Window t2 = new Window();
Window t3 = new Window();
t1.setName("窗口1");
t2.setName("窗口2");
t3.setName("窗口3");
t1.start();
t2.start();
t3.start();
}
}
运行结果为：可以看到有错票和重票
现在我们依葫芦画瓢修改代码，加上synchronized使其同步：
class Window extends Thread{
private Object obj = new Object();
private static int ticket = 100;
@Override
public void run() {
while(true){
synchronized (obj){
if (ticket>0){
try{
Thread.sleep(100);
}catch (InterruptedException e){
e.printStackTrace();
}
System.out.println(getName()+":卖票，票号为："+ticket);
ticket--;
}else{
break;
}
}
}
}
}
public class WindowTest {
public static void main(String[] args) {
Window t1 = new Window();
Window t2 = new Window();
Window t3 = new Window();
t1.setName("窗口1");
t2.setName("窗口2");
t3.setName("窗口3");
t1.start();
t2.start();
t3.start();
}
}
运行结果：可以看出并没有解决错票和重票
原因是我们在main方法中，new了三个Window对象，而每new一次对象，就会新new一个Object对象obj，这里就违反了多个线程必须共用同一把锁 这一要求
解决办法：在new 的obj对象前加一个static即可
private static Object obj = new Object();
可以看到运行结果为：成功
改进：我们依照实现Runnable接口的方式，用this当锁，这里是不行的，因为这里new了三个Window对象，那要怎么办呢？？？——每一个类都是一个对象，使用户当前类来充当同步监视器，并且这个类只会加载一次
synchronized (Window.class)
方式二：同步方法
如果操作共享数据的代码完整的声明在一个方法中，我们不妨将此方法声明成同步的
- 使用同步方法解决实现Runnable的线程安全问题
首先，将操作共享数据的代码抽取出来，形成一个新的方法，并且定义此方法为同步方法（并且把else–break去掉）
此时，这里的同步监视器为this
private synchronized void show(){//同步监视器为this
if (ticket>0){
try{
Thread.sleep(100);
}catch (InterruptedException e){
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName()+":卖票，票号为："+ticket);
ticket--;
}
}
完整代码为：
class Window2 implements Runnable{
//Object obj = new Object();
private int ticket = 100;
@Override
public void run() {
while(true){
show();
}
}
private synchronized void show(){//同步监视器为this
if (ticket>0){
try{
Thread.sleep(100);
}catch (InterruptedException e){
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName()+":卖票，票号为："+ticket);
ticket--;
}
}
}
public class WindowTest2 {
public static void main(String[] args) {
Window1 w = new Window1();
Thread t1 = new Thread(w);
Thread t2 = new Thread(w);
Thread t3 = new Thread(w);
t1.setName("窗口1");
t2.setName("窗口2");
t3.setName("窗口3");
t1.start();
t2.start();
t3.start();
}
}
- 使用同步方法解决继承Thread类的线程安全问题
首先，也是将操作共享数据的代码抽取出来，形成一个新的方法，并且定义为同步方法，而且要变成静态方法（方法内部方法也有变成静态的），因为如果不是静态的方法，那么将会被调用多次，此时同步监视器为Window3.class
class Window3 extends Thread{
private static int ticket = 100;
@Override
public void run() {
while(true){
show();
}
}
private static synchronized void show(){//同步监视器为Window3.class
if (ticket>0){
try{
Thread.sleep(100);
}catch (InterruptedException e){
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName()+":卖票，票号为："+ticket);
ticket--;
}
}
}
public class WindowTest3 {
public static void main(String[] args) {
Window3 t1 = new Window3();
Window3 t2 = new Window3();
Window3 t3 = new Window3();
t1.setName("窗口1");
t2.setName("窗口2");
t3.setName("窗口3");
t1.start();
t2.start();
t3.start();
}
}
关于同步方法的总结：
①同步方法仍涉及到同步监视器，只是不需要我们显式地声明
②非静态的同步方法，同步监视器为：this
静态的同步方法：同步监视器为：当前类本身
线程安全的单例模式之懒汉式
class Bank{
private Bank(){}
private static Bank instance = null;
public static Bank getInstance(){
// //方式一：效率稍差
// synchronized (Bank.class){
// if (instance == null){
// instance = new Bank();
// }
// return instance;
// }
//方式二：效率更高
if (instance == null){
synchronized (Bank.class){
if (instance == null){
instance = new Bank();
}
}
}
return instance;
}
}
线程的死锁问题
死锁：
》不同的线程分别占用对方需要的的同步资源不放弃，都在等待对方放弃自己需要的同步资源，就形成了线程的死锁
》出现死锁后，不会出现异常，不会出现提示，只是所有的线程都处于阻塞状态，无法继续
解决：
①专门的算法、原则 ②尽量减少同步资源的定义 ③尽量避免嵌套同步
例：下面代码是有可能出现死锁的，只不过出现死锁的概率比较小
public class ThreadTest2 {
public static void main(String[] args) {
StringBuffer s1 = new StringBuffer();
StringBuffer s2 = new StringBuffer();
new Thread(){
@Override
public void run() {
synchronized (s1){
s1.append("a");
s2.append("1");
synchronized (s2){
s1.append("b");
s2.append("2");
System.out.println(s1);
System.out.println(s2);
}
}
}
}.start();
new Thread(new Runnable() {
@Override
public void run() {
synchronized (s2){
s1.append("c");
s2.append("3");
synchronized (s1){
s1.append("d");
s2.append("4");
System.out.println(s1);
System.out.println(s2);
}
}
}
}){
}.start();
}
}
运行得出的一个结果为：
下面我们给代码加点东西（使用sleep），让其出现死锁的概率变高。
public class ThreadTest2 {
public static void main(String[] args) {
StringBuffer s1 = new StringBuffer();
StringBuffer s2 = new StringBuffer();
new Thread(){
@Override
public void run() {
synchronized (s1){
s1.append("a");
s2.append("1");
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
synchronized (s2){
s1.append("b");
s2.append("2");
System.out.println(s1);
System.out.println(s2);
}
}
}
}.start();
new Thread(new Runnable() {
@Override
public void run() {
synchronized (s2){
s1.append("c");
s2.append("3");
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
synchronized (s1){
s1.append("d");
s2.append("4");
System.out.println(s1);
System.out.println(s2);
}
}
}
}){
}.start();
}
}
现在就运行得不出结果了，出现死锁
是为什么呢？
上面的线程 握住s1这个同步监视器以后，再把s1和s2分别去append一下，再接下来就阻塞了，在其阻塞的0.1秒之内，下面这个线程太有可能执行了，下面的线程一执行，下面的现在握住s2，然后也sleep了，当他们两都醒的时候，上面的线程等着拿s2，下面的线程拿着s2等着s1，这样大家就互相僵持下去，所以就出现了死锁
方式三：Lock锁
从JDK5.0开始，Java提供了更强大的线程同步机制——通过显示定义同步锁对象来实现同步。同步锁用Lock对象充当
第一步：实例化ReentrantLock
private ReentrantLock lock = new ReentrantLock();
第二步：再把共享数据的代码放到try中，因为try中代码没有出错，所以最后写上finally
第三步：调用lock()
lock.lock();
这行代码就代表被锁住了，能保证在try过程中，是一个单线程的，当代码执行完，或者出现了异常，那就会执行finally代码
第四步：在finally中 解锁
finally {
lock.unlock();
}
完整代码为：
import java.util.concurrent.locks.ReentrantLock;
class Window1 implements Runnable{
private int ticket = 100;
private ReentrantLock lock = new ReentrantLock();
@Override
public void run() {
while(true){
try{
lock.lock();
if (ticket>0){
try{
Thread.sleep(100);
}catch (InterruptedException e){
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName()+":卖票，票号为："+ticket);
ticket--;
}
else{
break;
}
}finally {
lock.unlock();
}
}
}
}
public class WindowTest1 {
public static void main(String[] args) {
Window1 w = new Window1();
Thread t1 = new Thread(w);
Thread t2 = new Thread(w);
Thread t3 = new Thread(w);
t1.setName("窗口1");
t2.setName("窗口2");
t3.setName("窗口3");
t1.start();
t2.start();
t3.start();
}
}
synchronized与lock的异同
相同：二者都可以解决线程安全问题
不同：
synchronized机制在执行完相应的同步代码以后，自动的释放同步监视器
lock需要手动的启动同步（lock()），同时结束同步也需要手动的实现（unlock()）
优先使用顺序：
lock→同步代码块（已经进入了方法体，分配了相应的资源）→同步方法（在方法体之外）
练习：
分析：
- 是否是多线程问题：是，两个储户线程
- 是否有共享数据：有，账户（或账户余额）
- 是否有线程安全问题：有
- 如何解决线程安全问题：同步机制，三种方式
package lianxi;
class Account{
private double balance;
public Account(double balance) {
this.balance = balance;
}
public void deposit(double amt){
if (amt>0){
balance += amt;
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName()+":存钱成功，余额为："+balance);
}
}
}
class Customer extends Thread{
private Account acct;
public Customer(Account acct) {
this.acct = acct;
}
@Override
public void run() {
for (int i = 0; i < 3; i++) {
acct.deposit(1000);
}
}
}
public class AccountTest {
public static void main(String[] args) {
Account acct = new Account(0);
Customer c1 = new Customer(acct);
Customer c2 = new Customer(acct);
c1.setName("甲");
c2.setName("乙");
c1.start();
c2.start();
}
}
输出结果如下：出现了线程安全问题
解决办法：只需加一个synchronized即可
public synchronized void deposit(double amt){
输出结果：
五、线程的通信
线程的通信实际上就是几个方法的使用
涉及到的三个方法：
wait()：一旦执行此方法，当前线程就进入阻塞状态，并释放同步监视器
notify()：一旦执行此方法，就会唤醒被wait()的一个线程，如果有多个线程被wait()，就唤醒优先级高的那个
notifyAll()：一旦执行此方法，就会唤醒所有被wait()的线程
说明：
- 这三个方法必须使用在同步代码块或同步方法中。
- 这三个方法的调用者必须是同步代码块或同步方法中的同步监视器，否则会出现异常
- 这三个方法都是被定义在java.lang.Object类中
例：使用两个线程打印1-100，线程1，线程2交替打印
package lianxi;
class Number implements Runnable{
private int number=1;
@Override
public void run() {
while(true){
synchronized (this){
notify();
if(number<=100){
try {
Thread.sleep(10);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName()+":"+number);
number++;
try {
//使得调用wait()的线程进入阻塞状态
wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}else{
break;
}
}
}
}
}
public class CommunicationTest {
public static void main(String[] args) {
Number number = new Number();
Thread t1 = new Thread(number);
Thread t2 = new Thread(number);
t1.setName("线程1");
t2.setName("线程2");
t1.start();
t2.start();
}
}
代码的意思是：一开始线程1进来，因为没有wait()，所以无视notify(),把1打印出来了，然后wait()了。然后线程2进来，线程2一进来，就先notify()，就把线程1唤醒了，虽然把线程1唤醒了，但是此时线程2拿着同步监视器，所以线程1醒了，但是也进不来，因为线程2拿着锁，再接下来线程2输出了2，线程2就wait()了，执行了wait()了，会释放锁，线程1拿到了锁，线程1才能进来。。。。（以此往复）
输出结果如下：
sleep()和wait()的异同
相同点：一旦执行方法，都可以使得当前线程进入阻塞状态
不同点：
①两者声明的位置不同：Thread类中声明sleep()，Object类中声明wait()
②两者调用的要求不同：sleep()可以在任何需要的场景下调用，wait()必须使用在同步代码块或同步方法中
③关于是否释放同步监视器：若两个方法都使用在同步代码块或同步方法中，sleep()不会释放锁，wait()会释放锁
例题：
分析：
- 是否有多线程问题？是，生产者线程，消费者线程
- 是否有共享数据？是，店员（或产品）
- 如何解决线程的安全问题？同步机制，三种方法
- 是否涉及线程的通信？是
package lianxi;
class Productor extends Thread{
private Clerk clerk;
public Productor(Clerk clerk) {
this.clerk = clerk;
}
@Override
public void run() {
System.out.println(getName()+"：开始生产产品");
while (true){
try {
Thread.sleep(10);
} catch (InterruptedException e) {
e.printStackTrace();
}
clerk.produceProduct();
}
}
}
class Clerk{
private int productCount = 0;
//生产产品
public synchronized void produceProduct() {
if (productCount<20){
productCount++;
notify();
System.out.println(Thread.currentThread().getName()+":开始生产第"+productCount+"个产品");
}else{
try {
wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
//消费产品
public synchronized void consumeProduct() {
if (productCount>0){
System.out.println(Thread.currentThread().getName()+":开始消费第"+productCount+"个产品");
productCount--;
notify();
}else {
try {
wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
class Customer extends Thread{
private Clerk clerk;
public Customer(Clerk clerk) {
this.clerk = clerk;
}
@Override
public void run() {
System.out.println(getName()+":开始消费物品");
while(true){
clerk.consumeProduct();
}
}
}
public class ProductTest {
public static void main(String[] args) {
Clerk clerk = new Clerk();
Productor p1 = new Productor(clerk);
p1.setName("生产者1");
Customer c1 = new Customer(clerk);
c1.setName("消费者1");
p1.start();
c1.start();
}
}
本文地址：https://blog.csdn.net/fjswcjswzy/article/details/107498653