Java高级.线程安全

标签（空格分隔）： Java

多线程安全问题

方式一：同步代码块

synchronizd(同步监视器）{
需要同步的代码
}

说明：

操作共享数据的代码，即为需要被同步的代码----》不能包含过多代码，也不能包含过少
共享数据：多个线程共同操作的变量。比如：ticket就是共享数据
同步监视器：俗称：锁。任何一个类的对象，都可以充当锁
要求：多个线程必须要共用同一把锁

补充：在实现Runnable接口创建多线程的方式中，我们可以考虑使用this充当监视器

说明：在继承Thread类创建多线程的方法中，慎用this充当同步监视器，可以考虑使用当前类充当同步监视器

    解决：创建的多线程中线程安全问题
    package newday2.com.atguigu.java;

class Window1 implements Runnable{
    private int ticket = 100;
    Object obj = new Object();


    @Override
    public void run() {
        while (true) {
            //synchronized (obj) {//方法一
            synchronized(this){//方法二
                if (ticket > 0) {

                    try {
                        Thread.sleep(10);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }

                    System.out.println(Thread.currentThread().getName() + ":" + ticket);
                    ticket--;
                } else {
                    break;
                }
            }

        }
    }
}
public class Window {
    public static void main(String[] args) {
        Window1 window1 = new Window1();

        /*Thread t1 = new Thread(window1);
        Thread t2 = new Thread(window1);
        Thread t3 = new Thread(window1);

        t1.setName("窗口1：");
        t2.setName("窗口2：");
        t3.setName("窗口3：");

        t1.start();
        t2.start();
        t3.start();*/

        for (int i = 1; i < 4; i++) {
            Thread t = new Thread(window1,"窗口"+i);
            t.start();
        }
    }
}

解决：继承Thread中出现的多线程安全问题
    package newday2.com.atguigu.java;

class Window2 extends Thread{

    private static Object obj = new Object();//锁
    private static int ticket = 100;

    @Override
    public void run() {
        while (true){
            synchronized (obj){

                if(ticket > 0){

                    try {
                        Thread.sleep(10);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }

                    System.out.println(Thread.currentThread().getName()+":"+ticket);
                    ticket--;
                }else {
                    break;
                }
            }
        }
    }
}
public class WindowTow {
    public static void main(String[] args) {
        Window2 window2 = new Window2();

        Window2 t1 = new Window2();
        Window2 t2 = new Window2();
        Window2 t3 = new Window2();

        t1.setName("窗口1：");
        t2.setName("窗口2：");
        t3.setName("窗口3：");

        t1.start();
        t2.start();
        t3.start();
    }
}

方法二：同步方法

关于同步方法的总结：

同步方法任然涉及到同步监视器，只是不需要我们显示的声明
非静态的同步方法，同步监视器是：this

静态的同步方法，同步监视器是：当前类本身

解决：创建创建的多线程安全问题
class Window3 implements Runnable{
private int ticket = 100;

 @Override
 public void run() {
     while (true){
         show();
         if(ticket == 0){
             break;
         }
     }
 }

 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 WindowTest3 {
public static void main(String[] args) {
Window3 w = new Window3();

     Thread t1 = new Thread(w);
     Thread t2 = new Thread(w);
     Thread t3 = new Thread(w);

     t1.setName("窗口一");
     t2.setName("窗口一");
     t3.setName("窗口一");

     t1.start();
     t2.start();
     t3.start();
 }

}

解决：继承Thread中出现的多线程安全问题
    package newday2.com.atguigu.java;


class Window4 extends Thread{

    private static int ticket = 100;

    @Override
    public void run() {
        while (true){

        show();
            if(ticket == 0){
                break;
            }
        }

    }

    public static synchronized void show(){//同步监视器：Window4.class
//    public synchronized void show(){//同步监视器：t1，t2, t3//此种解决方式是错误的
        if(ticket > 0){

            try {
                Thread.sleep(10);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

            System.out.println(Thread.currentThread().getName()+":"+ticket);
            ticket--;
        }
    }
}
public class WindowTest4 {
    public static void main(String[] args) {
        Window4 window4 = new Window4();

        Window4 t1 = new Window4();
        Window4 t2 = new Window4();
        Window4 t3 = new Window4();

        t1.setName("窗口1：");
        t2.setName("窗口2：");
        t3.setName("窗口3：");

        t1.start();
        t2.start();
        t3.start();
    }
}

同步的方式：解决了线程的安全问题。-----好处
操作同步代码时，只能有一个线程参与，其他线程等待。相当于是一个单线程的过程。----局限性

单例模式

package newday2.com.atguigu.java;
/*
*
* */
public class BankTest {

}

class Bank{//单例模式：懒汉式
    private Bank(){}

    private static Bank instance = null;

    /*public static synchronized Bank getInstance(){*/


    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;
    }

}

线程的死锁问题

死锁
不同的线程分别占用对方需要的同步资源不放弃，都在等待对方放弃
自己需要的同步资源，就形成了线程的死锁
出现死锁后，不会出现异常，不会出现提示，只是所有的线程都处于
阻塞状态，无法继续
解决方法
专门的算法、原则
尽量减少同步资源的定义
尽量避免嵌套同步

线程安全问题解决办法三

Look锁
 从JDK 5.0开始，Java提供了更强大的线程同步机制——通过显式定义同
步锁对象来实现同步。同步锁使用Lock对象充当。
 java.util.concurrent.locks.Lock接口是控制多个线程对共享资源进行访问的
工具。锁提供了对共享资源的独占访问，每次只能有一个线程对Lock对象
加锁，线程开始访问共享资源之前应先获得Lock对象。
 ReentrantLock 类实现了 Lock ，它拥有与 synchronized 相同的并发性和
内存语义，在实现线程安全的控制中，比较常用的是ReentrantLock，可以
显式加锁、释放锁。

注意：如果同步代码有异常，要将unlock()写入finally语句块

package newday2.com.atguigu.java;

import java.util.concurrent.locks.ReentrantLock;

class Window5 implements Runnable{
    private int ticket = 100;
    //1. 实例化ReentrantLook
    private ReentrantLock lock = new ReentrantLock();

    @Override
    public void run() {
        while (true){
            try {
                //2. 调用锁定方法
                lock.lock();

                if(ticket > 0){
                    try {
                        Thread.sleep(10);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }

                    System.out.println(Thread.currentThread().getName() + ":" + ticket);
                    ticket--;
                }else {
                    break;
                }

            }finally {
                //3. 调用解锁方法：unlook
                lock.unlock();
            }
        }
    }
}

public class LookTest {
    public static void main(String[] args) {
        Window5 w = new Window5();

        Thread t1 = new Thread(w);
        Thread t2 = new Thread(w);
        Thread t3 = new Thread(w);

        t1.setName("窗口一：");
        t2.setName("窗口二：");
        t3.setName("窗口三：");

        t1.start();
        t2.start();
        t3.start();
    }
}

线程同步问题

题目：银行有一个账户。有两个储户分别向同一个账户存3000元，每次存1000，存三次。每次打印账户余额。

分析：

是否多线程问题：是，两个储户线程
是否共享数据？有，账户（或账户余额）
是否线程安全问题？有

需要考虑如何解决线程安全问题？同步机制：有三种办法。

继承
package newday2.com.atguigu.java;

class Account{
private double balance;

     public Account(double balance){
         this.balance = balance;
     }

     //存钱
     public synchronized 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();
 }

}

创建。。。

线程通信

例子：使用两个线程打印1-100，线程1，线程2，交替打印

线程通信涉及的三个方法：

wait（）：一旦执行此方法，当前线程就进入阻塞状态，并释放同步监视器。
notify() : 一旦执行此方法，就会唤醒被wait的一个线程。如果有多个线程被wait，就唤醒优先级高的那个
notifyAll() : 一旦执行此方法，就会唤醒所有被wait的线程。

说明：

wait(),notify(),notifyAll()三个方法必须使用在同步代码块或同步方法中。
wait(),notify(),notifyAll()三个方法的调用者必须是同步代码块或同步方法中的同步监视器否则，会出现IllegalMonitorStateException错误。

wait(),notify(),notifyAll()三个方法定义在java.long.object类中

package newday2.com.atguigu.java;

class Number implements Runnable{
private int number = 1;

@Override
public void run() {
    while (true){
        synchronized (this){

            notify();//唤醒语句

            if (number <= 100){
                System.out.println(Thread.currentThread().getName()+":"+number);
                number++;

                try {
                    wait();//使得调用如下wait()方法的线程进入阻塞状态
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }


            }else {
                break;
            }
        }
    }
}

}
public class Gommunication {
public static void main(String[] args) {
Number number = new Number();

    Thread t1 = new Thread(number);
    Thread t2 = new Thread(number);

    t1.setName("TO 1:");
    t2.setName("To 2:");

    t1.start();
    t2.start();
}

}

面试题：sleep() 和 wait() 的异同

相同点：一旦执行方法，都可以使得当前的线程进入阻塞状态。
不同点：
1）两个方法声明的位置不同：Thread类声明sleep（），object类中声明wait()。
2）调用的方式不同：sleep（）可以在任何需要的场景下使用。wait()必须使用在同步代码块或同步方法内
3）关于是否释放同步监视器：如果两个方法都是用在同步代码块或同步方法中，sleep()不会释放锁，wait()会释放锁。

线程通讯：生产者消费者例题

package newday2.com.atguigu.java;

class Clerk{

    private int productCount = 0;//产品数量

    //生产产品
    public synchronized void produceProduct() {
        if(productCount < 20){
            productCount++;
            System.out.println(Thread.currentThread().getName()+":开始生产第"+productCount + "个产品");
            notify();
        }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 Producer extends Thread{//生产者
    private Clerk clerk;

    public Producer(Clerk clerk){
        this.clerk = clerk;
    }

    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName()+":开始生产产品。。");
        while (true){

            try {
                Thread.sleep(10);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            clerk.produceProduct();
        }
    }
    
}

class Consumer extends Thread{//消费者
    private Clerk clerk;

    public Consumer(Clerk clerk){
        this.clerk = clerk;
    }

    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName()+":开始消费产品。。");
        while (true){

            try {
                Thread.sleep(20);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            clerk.consumeProduct();
        }

    }
}
public class ProductTest {
    public static void main(String[] args) {
        Clerk clerk = new Clerk();

        Producer p1 = new Producer(clerk);
        p1.setName("生产者1：");

        Consumer c1 = new Consumer(clerk);
        c1.setName("消费者1：");
        Consumer c2 = new Consumer(clerk);
        c2.setName("消费者2：");

        p1.start();
        c1.start();
        c2.start();
    }
}

新增线程创建方法

创建线程方式三：实现Callable接口

如何理解实现Callable接口的方式创建多线程比实现Runnable接口创建多线程方式强大？

call()可以有返回值的
call()可以抛出异常，被外面的操作捕获，获取异常信息
Callab是支持泛型的

package newday2.com.atguigu.java;

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. 将FutureTest的对象作为参数传递到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();
     }
 }
```
}

创建线程方式四：线程池

 背景：经常创建和销毁、使用量特别大的资源，比如并发情况下的线程，
对性能影响很大。
 思路：提前创建好多个线程，放入线程池中，使用时直接获取，使用完
放回池中。可以避免频繁创建销毁、实现重复利用。类似生活中的公共交
通工具。

 好处：

提高响应速度（减少了创建新线程的时间）
降低资源消耗（重复利用线程池中线程，不需要每次都创建）
便于线程管理
 corePoolSize：核心池的大小
 maximumPoolSize：最大线程数
 keepAliveTime：线程没有任务时最多保持多长时间后会终止
 …

线程池相关API

 JDK 5.0起提供了线程池相关API：ExecutorService 和 Executors
 ExecutorService：真正的线程池接口。常见子类ThreadPoolExecutor
 void execute(Runnable command) ：执行任务/命令，没有返回值，一般用来执行
Runnable
 Future submit(Callable task)：执行任务，有返回值，一般又来执行
Callable
 void shutdown() ：关闭连接池
 Executors：工具类、线程池的工厂类，用于创建并返回不同类型的线程池
 Executors.newCachedThreadPool()：创建一个可根据需要创建新线程的线程池
 Executors.newFixedThreadPool(n); 创建一个可重用固定线程数的线程池
 Executors.newSingleThreadExecutor() ：创建一个只有一个线程的线程池
 Executors.newScheduledThreadPool(n)：创建一个线程池，它可安排在给定延迟后运
行命令或者定期地执行。
线

posted @ 2024-08-08 11:20 我的十四行诗在哪里阅读(7) 评论(0) 编辑收藏举报

刷新页面返回顶部

登录后才能查看或发表评论，立即登录或者逛逛博客园首页

相关博文：

· Object

· Java基础（面向对象）

· Java——多线程（代码）

· JAVA---多线程1

· 多线程学习Java

阅读排行：
· 25岁的心里话
· 闲置电脑爆改个人服务器（超详细） #公网映射 #Vmware虚拟网络编辑器
· 零经验选手，Compose 一天开发一款小游戏！
· 因为Apifox不支持离线，我果断选择了Apipost！
· 通过 API 将Deepseek响应流式内容输出到前端

公告

昵称：我的十四行诗在哪里
园龄： 2年10个月
粉丝： 2
关注： 2

+加关注

2025年3月

日

一

二

三

四

五

六

fengmian13wl