Java_线程同步和死锁

Posted 2021-09-15 小企鹅推雪球!

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了Java_线程同步和死锁相关的知识，希望对你有一定的参考价值。

文章目录

Java_死锁的概念

Java_线程同步的概念

Java允许多线程并发控制,当多个线程同时操作一个客共享的资源变量时(如数据的增删改查)将会导致数据不准确,相互之间产生冲突,因此加入同步锁以避免在该线程没有完成操作之前,被其他线程调用了相关资源,从而保证了该资源的唯一性和准确性

Java_同步方法

使用synchronized关键字修饰的方法。
由于java的每个对象都有一个内置锁，当用此关键字修饰方法时，内置锁会保护整个方法。在调用该方法前，需要获得内置锁，否则就处于阻塞状态。public synchronized void save(){}
synchronized关键字也可以修饰静态方法，此时如果调用该静态方法，将会锁住整个类

Java_同步代码块

即有synchronized关键字修饰的语句块。被该关键字修饰的语句块会自动被加上内置锁，从而实现同步synchronized(object){ }
同步是一种高开销的操作，因此应该尽量减少同步的内容。
通常没有必要同步整个方法，使用`synchronized代码块同步关键代码即可。

package com.company;

// 线程同步实例
public class Java_35 {
    /**
     * 线程同步的运用
     *
     *
     *
     */

        class Bank {

            private int account = 100;

            public int getAccount() {
                return account;
            }

            /**
             * 用同步方法实现
             *
             * @param money
             */
            public synchronized void save(int money) {
                account += money;
            }

            /**
             * 用同步代码块实现
             *
             * @param money
             */
            public void save1(int money) {
                synchronized (this) {
                    account += money;
                }
            }
        }

        class NewThread implements Runnable {
            private Bank bank;

            public NewThread(Bank bank) {
                this.bank = bank;
            }

            @Override
            public void run() {
                for (int i = 0; i < 10; i++) {
                    // bank.save1(10);
                    bank.save(10);
                    System.out.println(i + "账户余额为：" + bank.getAccount());
                }
            }

        }

        /**
         * 建立线程，调用内部类
         */
        public void useThread() {
            Bank bank = new Bank();
            NewThread new_thread = new NewThread(bank);
            System.out.println("线程1");
            Thread thread1 = new Thread(new_thread);
            thread1.start();
            System.out.println("线程2");
            Thread thread2 = new Thread(new_thread);
            thread2.start();
        }

        public static void main(String[] args) {
            Java_35 j = new Java_35();
            j.useThread();
        }
}

Java_使用(volatile)实现线程同步

volatile关键字为域变量的访问提供了一种免锁机制，
使用volatile修饰域相当于告诉虚拟机该域可能会被其他线程更新，因此每次使用该域就要重新计算，而不是使用寄存器中的值
volatile不会提供任何原子操作，它也不能用来修饰final类型的变量

package com.company;

// 线程同步实例 使用 volatile 实现线程同步
public class Java_36 {
    /**
     * 线程同步的运用
     *
     *
     *
     */

    class Bank {

        private volatile  int account = 100;

        public int getAccount() {
            return account;
        }

        /**
         * 用同步方法实现
         *
         * @param money
         */
        public void save(int money) {
            account += money;
        }

        /**
         * 用同步代码块实现
         *
         * @param money
         */
        public void save1(int money) {
            synchronized (this) {
                account += money;
            }
        }
    }

    class NewThread implements Runnable {
        private Bank bank;

        public NewThread(Bank bank) {
            this.bank = bank;
        }

        @Override
        public void run() {
            for (int i = 0; i < 10; i++) {
                // bank.save1(10);
                bank.save(10);
                System.out.println(i + "账户余额为：" + bank.getAccount());
            }
        }

    }

    /**
     * 建立线程，调用内部类
     */
    public void useThread() {
        Bank bank = new Bank();
        NewThread new_thread = new NewThread(bank);
        System.out.println("线程1");
        Thread thread1 = new Thread(new_thread);
        thread1.start();
        System.out.println("线程2");
        Thread thread2 = new Thread(new_thread);
        thread2.start();
    }

    public static void main(String[] args) {
        Java_35 j = new Java_35();
        j.useThread();
    }
}

注意:

多线程中的非同步问题主要出现在对域的读写上,如果让域自身避免这个问题,则不需要修改操作该域的方法
用 final 域,有锁保护域和volatile域可以避免非同步的问题

Java_使用重入锁实现线程同步

在JavaSE5.0中新增了一个java.util.concurrent包来支持同步。
ReentrantLock类是可重入、互斥、实现了Lock接口的锁，它与使用synchronized方法和快具有相同的基本行为和语义，并且扩展了其能力

ReenreantLock类的常用方法有:

ReentrantLock(): 创建一个ReentrantLock实例
lock():获得锁
unlock():释放锁

package com.company;

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

// 线程同步实例 使用 ReentrantLock 实现线程同步
public class Java_37 {
    /**
     * 线程同步的运用
     *
     *
     *
     */

    class Bank {

        private  int account = 100;
//        需要声明这个锁
        private Lock lock = new ReentrantLock();
        public int getAccount(){
            return account;
        }

        /**
         * 用同步方法实现
         *
         * @param money
         */
        public void save(int money) {
            lock.lock(); // 上锁
            try{
                account += money;
            } finally {
                lock.unlock(); // 释放锁
            }

        }

        /**
         * 用同步代码块实现
         *
         * @param money
         */
        public void save1(int money) {
            synchronized (this) {
                account += money;
            }
        }
    }

    class NewThread implements Runnable {
        private Bank bank;

        public NewThread(Bank bank) {
            this.bank = bank;
        }

        @Override
        public void run() {
            for (int i = 0; i < 10; i++) {
                // bank.save1(10);
                bank.save(10);
                System.out.println(i + "账户余额为：" + bank.getAccount());
            }
        }

    }

    /**
     * 建立线程，调用内部类
     */
    public void useThread() {
        Bank bank = new Bank();
        NewThread new_thread = new NewThread(bank);
        System.out.println("线程1");
        Thread thread1 = new Thread(new_thread);
        thread1.start();
        System.out.println("线程2");
        Thread thread2 = new Thread(new_thread);
        thread2.start();
    }

    public static void main(String[] args) {
        Java_35 j = new Java_35();
        j.useThread();
    }
}

注意:

如果synchronized关键字能满足用户的需求就是用synchronized,
如果需要更加复杂的需求,就使用ReentrantLock类,但是要注意释放锁,否则会出现死锁,通过在finally代码释放锁

Java_使用局部变量实现线程同步

如果使用ThreadLocal管理变量,则每一个使用该变量的线程都获得该变量的副本
副本之间相互独立,这样每个线程都可以随意修改自己的变量副本,而不会对其他线程产生影响

ThreadLocal类的常用方法

ThreadLocal():创建一个线程本地变量
get():返回此线程局部变量的当前线程副本中的值
initialValue():返回此线程局部变量的当前线程的初始值
set(T value):将此线程局部变量的当前线程副本中的值设置为value

package com.company;

// 线程同步实例 使用 局部变量 实现线程同步
public class Java_38 {
    /**
     * 线程同步的运用
     *
     *
     *
     */

    class Bank {

        //使用ThreadLocal类管理共享变量account
        private static ThreadLocal<Integer> account = new ThreadLocal<Integer>(){
            @Override
            protected Integer initialValue(){
                return 100;
            }
        };
        public void save(int money){
            account.set(account.get()+money);
        }
        public int getAccount(){
            return account.get();
        }
    }

    class NewThread implements Runnable {
        private Bank bank;

        public NewThread(Bank bank) {
            this.bank = bank;
        }

        @Override
        public void run() {
            for (int i = 0; i < 10; i++) {
                // bank.save1(10);
                bank.save(10);
                System.out.println(i + "账户余额为：" + bank.getAccount());
            }
        }

    }

    /**
     * 建立线程，调用内部类
     */
    public void useThread() {
        Bank bank = new Bank();
        NewThread new_thread = new NewThread(bank);
        System.out.println("线程1");
        Thread thread1 = new Thread(new_thread);
        thread1.start();
        System.out.println("线程2");
        Thread thread2 = new Thread(new_thread);
        thread2.start();
    }

    public static void main(String[] args) {
        Java_35 j = new Java_35();
        j.useThread();
    }
}

注意:

ThreadLocal与同步机制都是为了解决多线程中相同变量的访问冲突问题。
前者采用以"空间换时间"的方法，后者采用以"时间换空间"的方式

Java_使用阻塞队列实现线程同步

使用LinkedBlockingQueue<E>来实现线程的同步
LinkedBlockingQueue<E>是一个基于已连接节点的，范围任意的blocking queue。
队列是先进先出的顺序（FIFO）的数据结构

LinkedBlockingQueue 类常用方法
4. LinkedBlockingQueue(): 创建一个容量为Integer.MAX_VALUE的LinkedBlockingQueue
5. put(E e): 在队尾添加一个元素，如果队列满则阻塞
6. size(): 返回队列中的元素个数
7. take() : 移除并返回队头元素，如果队列空则阻塞

package com.xhj.thread;

import java.util.Random;
import java.util.concurrent.LinkedBlockingQueue;

/**
 * 用阻塞队列实现线程同步 LinkedBlockingQueue的使用
 *
 * @author XIEHEJUN
 *
 */
public class BlockingSynchronizedThread {
    /**
     * 定义一个阻塞队列用来存储生产出来的商品
     */
    private LinkedBlockingQueue<Integer> queue = new LinkedBlockingQueue<Integer>();
    /**
     * 定义生产商品个数
     */
    private static final int size = 10;
    /**
     * 定义启动线程的标志，为0时，启动生产商品的线程；为1时，启动消费商品的线程
     */
    private int flag = 0;

    private class LinkBlockThread implements Runnable {
        @Override
        public void run() {
            int new_flag = flag++;
            System.out.println("启动线程 " + new_flag);
            if (new_flag == 0) {
                for (int i = 0; i < size; i++) {
                    int b = new Random().nextInt(255);
                    System.out.println("生产商品：" + b + "号");
                    try {
                        queue.put(b);
                    } catch (InterruptedException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    }
                    System.out.println("仓库中还有商品：" + queue.size() + "个");
                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    }
                }
            } else {
                for (int i = 0; i < size / 2; i++) {
                    try {
                        int n = queue.take();
                        System.out.println("消费者买去了" + n + "号商品");
                    } catch (InterruptedException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    }
                    System.out.println("仓库中还有商品：" + queue.size() + "个");
                    try {
                        Thread.sleep(100);
                    } catch (Exception e) {
                        // TODO: handle exception
                    }
                }
            }
        }
    }

    public static void main(String[] args) {
        BlockingSynchronizedThread bst = new BlockingSynchronizedThread();
        LinkBlockThread lbt = bst.new LinkBlockThread();
        Thread thread1 = new Thread(lbt);
        Thread thread2 = new Thread(lbt);
        thread1.start();
        thread2.start();

    }

}

Java_死锁的概念

死锁是指多个线程同时被阻塞时,他们中的一个或者全部都在等待某个资源被释放,但是由于线程被无限期的阻塞,因为程序不可能正常终止

Java_死锁产生的四个必要条件

互斥使用:即当资源被一个线程使用(占有时),别的线程不能使用
不可抢占,资源请求者不能强制从资源占有者手中夺取资源,资源只能由资源占有者主动释放
请求和保持:即当资源请求者在请求其他的资源的同时保持对原有资源的占用
循环等待:即存在一个等待队列,P1占有P2的资源,P2占有P3的资源,P3占有P1的资源,这样就形成了一个等待环路

当上诉四个条件都成立时,形成死锁,是同时成立

Java_synchronized死锁

死锁的样例

package com.company;
import java.util.Date;
// 死锁的样例
public class Java_39 {
//    使用
    public static String obj1 = "obj1";
    public static String obj2 = "obj2";
    public static void main(String[] args) {
        LockA la = new LockA();
        new Thread(la).start();
        LockB lb = new LockB();
        new Thread(lb).start();
    }
}
class LockA implements Runnable{
    public void run() {
        try {
            System.out.println(new Date().toString() + " LockA 开始执行");
            while(true){
                synchronized (Java_39.obj1) {
                    System.out.println(new Date().toString() + " LockA 锁住 obj1");
                    Thread.sleep(3000); // 此处等待是给B能锁住机会
                    synchronized (Java_39.obj2) {
                        System.out.println(new Date().toString() + " LockA 锁住 obj2");
                        Thread.sleep(60 * 1000); // 为测试，占用了就不放
                    }
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}
class LockB implements Runnable{
    public void run() {
        try {
            System.out.println(new Date().toString() + " LockB 开始执行");
            while(true){
                synchronized (Java_39.obj2) {
                    System.out.println(new Date().toString() + " LockB 锁住 obj2");
                    Thread.sleep(3000); // 此处等待是给A能锁住机会
                    synchronized (Java_39.obj1) {
                        System.out.println(new Date().toString() + " LockB 锁住 obj1");
                        Thread.sleep(60 * 1000); // 为测试，占用了就不放
                    }
                }
            }
        } catch 以上是关于Java_线程同步和死锁的主要内容，如果未能解决你的问题，请参考以下文章 
 Java中线程死锁问题
 Java多线程：线程同步详解
 Java多线程产生死锁的一个简单案例
 JAVA SE基础篇59.同步块并发容器和死锁
 java -- 线程
 Java面试宝典线程安全问题|线程死锁的出现|线程安全的集合类