线程不安全问题

线程不安全问题

使用Runnable接口实现多线程，多个线程操作同一个资源时，线程不安全，出现并发问题。如多个人同时抢票，会出现多个人抢了同一张票的问题，代码如下

//多个线程同时操作同一个对象
//问题：多个线程操作同一个资源的情况下，线程不安全，数据紊乱，并发问题
public class TestThread5 implements Runnable{

//    票数
    private int ticketName=10;

    @Override
    public void run(){
        while(true){
            if(ticketName<=0){
                break;
            }
            try {
                Thread.sleep(200);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName()+"拿到了"+ticketName--+"票");
        }
    }
    public static void main(String[] args){
        TestThread5 testThread5=new TestThread5();

        new Thread(testThread5,"小明").start();
        new Thread(testThread5,"老师").start();
        new Thread(testThread5,"小张").start();
    }
}

 并发：同一个对象被多个线程同时操作。

处理多线程问题时，多个线程访问同一个对象，并且某些线程好像修改这一对象，这时就需要线程同步，线程同步是一种等待机制，多个需要同时访问此对象的线程进入对象的等待池形成队列，等待前面的线程使用完毕，下一个线程再使用。

线程同步实现需要队列+锁，每个对象都有一把锁，解决线程不安全问题。

由于同一进程的多个线程共享同一块存储空间，带来方便的同时也带来了冲突的问题，为了保证数据在方法中被访问的正确性，在访问时加入锁机制synchronized，当一个线程获得对象的排它锁时，独占资源，其他线程必须等待，使用后释放锁即可，存在以下问题：

一个线程持有锁会导致其他所有需要此锁的线程挂起。

在多线程竞争下，加锁、释放锁会导致比较多的上下文切换和调度延时，引起性能问题，效率变低。

如果一个优先级高的线程等待一个优先级低的线程释放锁，会导致优先级倒置，导致性能问题。

 

死锁：

多个线程各自占有一些共享资源，并且互相等待其他线程占有的资源才能运行，导致两个或多个线程都在等待对方释放资源，都停止执行的
情形，某一个同步块同时拥有两个以上对象的锁时，都有可能发生死锁。
死锁的必要条件：
互斥条件，一个资源每次只能被一个进程使用。
请求与保持条件：一个进程因请求资源而阻塞时，对以获得的资源保持不放。
不剥夺条件：进程已获得的资源，在未使用完之前不能强行剥夺。
循环等待条件：若干进程之间形成一种头尾相接的循环等待资源关系。

 

写代码时注意不能发生死锁问题。

解决线程不安全问题的三种方法：

1.同步方法

就是在线程类里面的run()方法前加入关键字sychronized

 

synchronized关键字，有两种用法，sychronized方法
同步方法：public sychronized void method(int args){}
sychronized方法控制对“对象”的访问，每个对象对应一把锁，每个sychronized方法都必须获得调用该方法的对象的锁才能执行，否则线程会阻塞，
方法一旦执行就独占该锁，直到该方法返回才释放锁，后面被阻塞的线程才能获得这个锁，继续执行
缺点：效率低

package com.threadsafe;

public class UnsafeThread {
    public static void main(String[] args) {
        BuyTicket buyTicket=new BuyTicket();
        new Thread(buyTicket,"123").start();
        new Thread(buyTicket,"yi").start();
        new Thread(buyTicket,"zhang").start();
    }
}

class BuyTicket implements Runnable{
    private int ticketNum=10;
    boolean flag=true;
    @Override
    public void run() {
        while(flag){
            buy();
        }

    }
//    同步方法
    private synchronized void buy(){
        if(ticketNum<=0){
            flag=false;
            return;
        }
        try {
            Thread.sleep(100);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName()+"拿到"+ticketNum--);
    }
}

 

2.同步代码块

因为同步方法只能加在run()方法前，这只能对该方法的对象枷锁，也就是类本身，但是有时候增删改的对象不是类本身，而是其他的类，这时候就需要对别的对象加锁，同步方法不能实现这个功能，需要使用同步代码块实现。

sychronized(Obj){}
Obj称为同步监视器
Obj可以是任何对象，但是推荐使用共享资源作为同步监视器。
同步方法无需指定同步监视器，因为同步方法的同步监视器就是this，就是这个对象本身，也就是class
同步监视器的执行过程：
第一个线程访问，锁定同步监视器，执行其中代码
第二个线程访问，发现同步监视器被锁定，无法访问
第一个线程访问完毕，解锁同步监视器
第二个线程访问，发现同步监视器没有锁，然后锁定并访问

package com.threadsafe;

public class UnsafeBank {
    public static void main(String[] args) {
        Account account=new Account(100,"基金");
        Drawing drawing=new Drawing(account,100,"you");
        Drawing drawing1=new Drawing(account,50,"me");
        drawing.start();
        drawing1.start();
    }
}

class Account{
    int money;
    String name;

    public Account(int money, String name) {
        this.money = money;
        this.name = name;
    }
}

class Drawing extends Thread{

    Account account;
    int drawmoney;
    int nowmoney;
    public Drawing(Account account,int drawmoney,String name){
        super(name);
        this.account=account;
        this.drawmoney=drawmoney;
    }

    @Override
    public void run() {
//        锁的对象就是变化的对象，需要增删改
        synchronized (account){
            if(account.money-drawmoney<0){
                System.out.println(Thread.currentThread().getName()+"钱不够了");
                return;
            }
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            account.money=account.money-drawmoney;
            nowmoney=nowmoney+drawmoney;
            System.out.println("余额"+account.money);
            System.out.println("手里的钱"+nowmoney);

        }
        }

}

 

3.LOCK锁

 

package com.lock;

import java.util.concurrent.locks.ReentrantLock;

public class TestLock {
    public static void main(String[] args) {
        ticket ticket1=new ticket();
        new Thread(ticket1).start();
        new Thread(ticket1).start();
        new Thread(ticket1).start();
    }

}


class ticket implements Runnable{
    int ticketNum=10;
    private final ReentrantLock lock=new ReentrantLock();

    @Override
    public void run() {
        while(true){
            try{
                lock.lock();
                if(ticketNum>0){
                    try {
                        Thread.sleep(3000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(ticketNum--);
                }else{
                    break;
                }
            }finally {
                lock.unlock();
            }

        }
    }
}

 

Sychronized和Lock的区别

Lock是显示锁，需要手动开启和关闭锁，sychronized是隐式锁，出了作用域自动释放。

Lock只有代码块锁，sychronized有代码块锁和方法锁。

使用lock锁，JVM将花费较少的时间调度线程，性能更好。

Lock锁>同步代码块>同步方法