线程安全问题和解决方案

最新推荐文章于 2023-04-03 22:30:48 发布

刘大哥就是6

最新推荐文章于 2023-04-03 22:30:48 发布

阅读量562

点赞数 2

分类专栏： java学习

本文链接：https://blog.csdn.net/tony_yang6/article/details/106098733

版权

java学习专栏收录该内容

59 篇文章 1 订阅

订阅专栏

1.线程安全问题-共享资源能使用问题

2.同步代码块

synchronize( /*锁对象 */){

}

/*
特征:
    1. synchronized 小括号里面的对象是锁对象，并且要求如果是多线程的情况下，锁对象必须是同一个对象。
    2. synchronized 大括号中的代码块就是需要进行同步的代码，或者说是加锁的代码，大括号里面的内容，有且只允许一个线程进入。
    3. 同步代码块越短越好，在保证安全的情况下，提高性能

问题:
   1. 目前锁对象感觉很随意，存在一定的隐患
   2. 代码层级关系很复杂，看着有点麻烦
*/

package com.qfedu.b_synchronized;
/*
 * 共享资源冲突问题
 */

/**
 * 自定义售票线程类
 * 
 * @author Anonymous
 *
 */
class SingleThread implements Runnable {

	// 共享资源
	private static int ticket = 100;

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

			if (ticket > 0) {
				System.out.println(Thread.currentThread().getName() + "售出了" + ticket + "张票");
				ticket -= 1;

				try {
					Thread.sleep(100);
				} catch (InterruptedException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
			} else {
				System.out.println(Thread.currentThread().getName() + "售罄！");
				break;
			}

		}
	}
}

public class Demo1 {
	public static void main(String[] args) {
		Thread thread1 = new Thread(new SingleThread(), "淘票票");
		Thread thread2 = new Thread(new SingleThread(), "猫眼");
		Thread thread3 = new Thread(new SingleThread(), "美图");
		
		thread1.start();
		thread2.start();
		thread3.start();
	}
}

3.同步方法

synchronized 作为关键字来修饰方法，修饰的方法就是对应的同步方
有且只允许一个线程进入，到底是谁来完成的加锁操作?

1. 静态成员方法
锁对象，是当前类对应的字节码文件.class 类名.class
2. 非静态成员方法
锁对象就是当前类对象 this

选择同步方法是否使用static修饰问题
   1. 如果非static修饰，要保证执行的线程对象有且只有一个，因为锁对象就是当前线程对
象

   2. 如果是static修饰，锁对象具有唯一性，多个线程使用的锁是同一个锁。

package com.Demo2;


/*
 * 共享资源冲突问题
 */

/**
 * 自定义售票线程类
 *
 * @author Anonymous
 *
 */
class SingleThread implements Runnable {

    // 共享资源
    private static int ticket = 100;

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

            /**
             * 调用一个同步方法
             */
            sellTicket();
            if (0==ticket){
                break;
            }



        }
    }

    /**
     * 完成一个同步方法，该方法是一个非静态成员方法，所对象就是this.当前类对象
     */
    public synchronized void sellTicket(){
        if (ticket > 0) {
            System.out.println(Thread.currentThread().getName() + "售出了" + ticket + "张票");
            ticket -= 1;

            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        } else {
            System.out.println(Thread.currentThread().getName() + "售罄！");

        }


    }
}


public class Demo1 {
    public static void main(String[] args) {
        Thread thread1 = new Thread(new SingleThread(), "淘票票");
        Thread thread2 = new Thread(new SingleThread(), "猫眼");
        Thread thread3 = new Thread(new SingleThread(), "美图");

        thread1.start();
        thread2.start();
        thread3.start();
    }
}

4.Lock锁

Java提供了一个对于线程安全问题，加锁操作相对于同步代码块和同步方法更加广泛的一种操作方式。
1. 对象化操作。
   创建Lock构造方法
       Lock lock = new ReentrantLock();
2. 方法化操作。
   开锁:
       unlock();
   加锁:
       lock();

package com.qfedu.b_synchronized;

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

/*
 * 共享资源冲突问题
 */

/**
 * 自定义售票线程类
 * 
 * @author Anonymous
 *
 */
class SingleThread5 implements Runnable {

	// 共享资源
	private static int ticket = 100;
	
	// 定义一个成员变量
	static Lock lock = new ReentrantLock();
	
	@Override
	public void run() {
		while (true) {

			// lock对象加锁
			lock.lock();
			if (ticket > 0) {
				System.out.println(Thread.currentThread().getName() + "售出了" + ticket + "张票");
				ticket -= 1;

				try {
					Thread.sleep(100);
				} catch (InterruptedException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
			} else {
				System.out.println(Thread.currentThread().getName() + "售罄！");
				break;
			}

			// 解除锁
			lock.unlock();
		}
	}
}

public class Demo5 {
	public static void main(String[] args) {
		
		Thread thread1 = new Thread(new SingleThread5(), "淘票票");
		Thread thread2 = new Thread(new SingleThread5(), "猫眼");
		Thread thread3 = new Thread(new SingleThread5(), "美图");
		
		thread1.start();
		thread2.start();
		thread3.start();
	}
}

5.三种加锁方式的总结

1. 一锁一线程，一锁多线程问题。
   使用对应的锁操作对应的线程，考虑静态和非静态问题。
   同步方法和Lock锁使用。
   静态是一锁多目标，非静态是一锁一目标

2. 涉及到同步问题时，要考虑好锁对象的选择问题
同步代码块，同步方法，Lock对象。

6.守护线程

守护线程，也称之为后台线程，如果当前主线程GG思密达，守护线程也就GG思密达。

守护线程一般用于:
   1. 自动下载
   2. 操作日志
   3. 操作监控

方法是通过线程对象
   setDeamon(boolean flag);
       true为守护线程
       false缺省属性，正常线程

7.线程状态

7.1线程六大状态

7.2TIMED_WAITING(计时等待)

Thread.sleep(int ms);
   在对应线程代码块中，当前线程休眠指定的时间。
Object类内 wait(int ms);
   让当前线程进入一个计时等待状态
       1. 规定的时间及时完毕，线程回到可运行状态
       2. 在等待时间内，通过其他线程被notify或者notifyAll唤醒

Sleep方法
   1. 调用之后休眠指定时间
   2. sleep方法必须执行在run方法内，才可以休眠线程
   3. sleep不会打卡当前线程占用的锁对象。

7.3 BLOCKED(锁阻塞)

线程中有锁存在，线程需要进入带有锁操作的同步代码，如果锁对象被别人持有，只能在锁外等待

锁阻塞状态的线程是否能够抢到锁对象有很多因素
1. 优先级问题，非决定因素
2. CPU执行概率问题。

后期高并发一定会存在多线程操作锁对象问题，秒杀，抢购...
队列方式来处理

刘大哥就是6

关注

2
点赞
踩
4

收藏

觉得还不错? 一键收藏
0
评论
线程安全问题和解决方案

1.线程安全问题-共享资源能使用问题2.同步代码块 synchronize( /*锁对象 */){}/*特征: 1. synchronized 小括号里面的对象是锁对象，并且要求如果是多线程的情况下，锁对象必须是同一个对象。 2. synchronized 大括号中的代码块就是需要进行同步的代码，或者说是加锁的代码，大括号里面的内容，有且只允许一个线程进入。 3. 同步代码块越短越好，在保证安全的情况下，提高性能问题: 1. 目前锁对...
复制链接

扫一扫