Java----线程学习(线程同步)

1）在线程没有同步时会导致不安全

◆线程就是独立的执行路径;
◆在程序运行时，即使没有自己创建线程，后台也会有多个线程，如主线程，gc线程;
◆main()称之为主线程，为系统的入口，用于执行整个程序; 
◆在一个进程中，如果开辟了多个线程,线程的运行由调度器安排调度,调度器是与操作系统紧密相关的，先后顺序是不能认为的干预的。
◆对同一份资源操作时，会存在资源抢夺的问题，需要加入并发控制;
◆线程会带来额外的开销，如cpu调度时间，并发控制开销。
◆每个线程在自己的工作内存交互,内存控制不当会造成数据不一致
下面来看一下例子：我们再次模拟买票的小例子

代码如下：

package edu.ncu.dong.Thread;
//不安全的买票
public class BuyTicketsUnsafely {
    public static void main(String[] args) {
        BuyTickets buyTickets=new BuyTickets();
        new Thread(buyTickets,"黄牛").start();
        new Thread(buyTickets,"小兰").start();
        new Thread(buyTickets,"小刘").start();
    }
}

class BuyTickets implements Runnable{
    private int tickets=20;//票数
    private boolean flag=true;//线程停止标志
    @Override
    public void run() {
        while (flag){
            try {
                Buy();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    /**
     * 买票方法
     */
    private void Buy() throws InterruptedException {
        //判断票数
        if (tickets<=0){
            flag=false;
            return;
        }
        //模拟买票
        Thread.sleep(1*1000);
        System.out.println(Thread.currentThread().getName()+" buy the No."+ tickets-- +" tickets");
    }
}

查看结果：

可以看出：三个人同时买了第5张票，而且票数反而增加了，这便是不进行线程同步出现的问题。

我们再来看一个线程不安全的集合：list

package edu.ncu.dong.Thread.synchrnd;

import java.util.ArrayList;
import java.util.List;

public class UnsafeCollection {
    public static void main(String[] args) throws InterruptedException {
        List<String> list=new ArrayList<>();
        //理论上是创建100000个线程，把他们的名字放入list集合
        for (int i = 0; i < 100000; i++) {
            new Thread(()->{
                list.add(Thread.currentThread().getName());
            }).start();
        }
        Thread.sleep(1*1000);
        System.out.println("list的大小是："+list.size());
    }
}

                  

查看结果发现，list.size()只有99995，这是因为list是不安全的，有可能同一个索引被多次引用了，导致某个索引下的值被覆盖。

2）线程同步

◆由于我们可以通过private关键字来保证数据对象只能被方法访问,所以我们只需要针对方法提出一套机制,这套机制就是synchronized关键字,它包括两种用法:synchronized方法(synchronized修饰的方法是为this对象加锁)和synchronized块.
同步方法: public synchronized void method(int args) {...}
◆synchronized方法控制对 “对象”的访问,每个对象对应一把锁 ,每个synchronized方法都必须获得调用该方法的对象的锁才能执行,否则线程会阻塞，方法一旦执行,就独占该锁,直到该方法返回才释放锁,后面被阻塞的线程才能获得这个锁,继续执行
缺陷:若将一个很大的方法声明为synchronized将会影响效率
◆方法里面需要修改的内容才需要锁，锁太多会浪费资源

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

我们将第一个买票的问题加上synchronized关键字修饰，就便是安全的线程了：

 运行结果：

看另一个使用同步块的例子，多个人对同一个账户取钱

在没有进行线程同步时：

package edu.ncu.dong.Thread.synchrnd;

public class DrawMoney {

    public static void main(String[] args) {
        Account account=new Account("基金",10000);//同一个账户
        Drawing me=new Drawing(account,1000,"我自己");//我自己取钱
        Drawing she=new Drawing(account,2000,"女朋友");//女朋友取钱
        me.start();
        she.start();
    }
}

/**
 * 账户对象
 */
class Account{
    String name;
    int money;//余额

    public Account(String name, int money) {
        this.name = name;
        this.money = money;
    }
}
/**
 银行
 */
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() {
        while (true){
            if (account.money-drawMoney<0){
                System.out.println(Thread.currentThread().getName()+",钱不够了，无法取钱！");
                return;
            }
            account.money-=drawMoney;//账户余额
            nowMoney+=drawMoney;//手里的钱
            System.out.println(account.name+"账户余额："+account.money+";"+Thread.currentThread().getName()+"手中的钱："+nowMoney);
        }
    }
}

 运行结果：发现余额为负的值了

 我们使用同步块：

package edu.ncu.dong.Thread.synchrnd;

public class DrawMoney {

    public static void main(String[] args) {
        Account account=new Account("基金",10000);//同一个账户
        Drawing me=new Drawing(account,1000,"我自己");//我自己取钱
        Drawing she=new Drawing(account,2000,"女朋友");//女朋友取钱
        me.start();
        she.start();
    }
}

/**
 * 账户对象
 */
class Account{
    String name;
    int money;//余额

    public Account(String name, int money) {
        this.name = name;
        this.money = money;
    }
}
/**
 银行
 */
class Drawing extends Thread {
    Account account;//账户
    int drawMoney;//取钱金额
    int nowMoney;//手里的钱
    boolean flag=true;//标识线程是否退出
    public Drawing(Account account,int drawMoney,String name){
        super(name);
        this.account=account;
        this.drawMoney=drawMoney;
    }

    @Override
    public void run() {
            while (flag) {
                synchronized (account) {
                    if (account.money - drawMoney < 0) {
                        System.out.println(Thread.currentThread().getName() + ",钱不够了，无法取钱！");
                        flag = false;
                        return;
                    }
                    account.money -= drawMoney;//账户余额
                    nowMoney += drawMoney;//手里的钱
                    System.out.println(Thread.currentThread().getName() + "取钱了，" + account.name + "账户余额：" + account.money + ";" +
                            Thread.currentThread().getName() + "手中的钱：" + nowMoney);
                }
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
    }
}

运行结果：可以发现，安全进行，女朋友取2000，账户只有1000了，无法取钱，我只取1000，可以取

前面提到了一个ArrayList不安全的问题，我们可以使用JUC(java.util.concurrent包)下的list类型，例如：

package edu.ncu.dong.Thread.synchrnd;
import java.util.concurrent.CopyOnWriteArrayList;
/**
 * 测试JUC安全类型的集合 JUC：java.util.concurrent
 */
public class TestJUC {
    public static void main(String[] args) throws InterruptedException {
        CopyOnWriteArrayList<String> list=new CopyOnWriteArrayList<String>();//安全的list类型，ArrayList是不安全的类型
        for (int i = 0; i < 10000; i++) {
            new Thread(()->{
                list.add("线程名字："+Thread.currentThread().getName());
            }).start();
        }
        Thread.sleep(2*1000);
        System.out.println(list.get(9999).toString());
        System.out.println("size="+list.size());
    }
}

运行结果如下：是安全的

 3）死锁

在线程运行过程中，多个线程互相拥有对方需要的资源，从而造成僵持的状态，导致程序无法停止，形成死锁。

◆产生死锁的四个必要条件:
1. 互斥条件:一个资源每次只能被一 个进程使用。
2.请求与保持条件: 一个进程因请求资源而阻塞时，对已获得的资源保持不放。
3.不剥夺条件 :进程已获得的资源，在末使用完之前，不能强行剥夺。
4.循环等待条件:若干进程之间形成-种头尾相接的循环等待资源关系。
上面列出了死锁的四个必要条件，我们只要想办法破其中的任意一个或多 个条件就可以避免死锁发生

举个例子，这里有两个资源类Mirror和LipsStick，且在化妆类（MakeUp）中都是只有一份（static修饰），现在创建两个线程girl1和girl2，互相锁了（synchronized）对方需要的资源，造成死锁：

package edu.ncu.dong.Thread.synchrnd;

/**
 * 死锁测试
 */
public class TestDeadLock {
    public static void main(String[] args) {
        MakeUp girl1=new MakeUp(0,"灰姑凉");
        MakeUp girl2=new MakeUp(1,"老巫婆");
        girl1.start();
        girl2.start();
    }
}
//口红
class LipsStick{
    //nothing
}
//镜子
class Mirror {
    //nothing
}
//化妆类
class MakeUp extends Thread{
    //一份资源，用static保证
    static LipsStick lipsStick=new LipsStick();
    static Mirror mirror=new Mirror();

    int choice;//选择
    String girl;//女生名字
    //构造
    MakeUp(int choice,String girl){
        this.choice=choice;
        this.girl=girl;
    }
    @Override
    public void run(){
        try {
            makeUp();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
    //化妆方法，用于拿到对方的资源
    private void makeUp() throws InterruptedException {
        if(choice==0){
            synchronized (lipsStick){//给lipsStick加锁
                System.out.println(girl+"获得了口红！");
                Thread.sleep(1*1000);
                synchronized (mirror){//1秒钟之后，给mirror加锁
                    System.out.println(girl+"1秒后获得了镜子！");
                }
            }
        }
        else if (choice==1){
            synchronized (mirror){//mirror
                System.out.println(girl+"获得了镜子！");
                Thread.sleep(1*1000);
                synchronized (lipsStick){//1秒钟之后，给lipsStick加锁
                    System.out.println(girl+"1秒后获得了口红！");
                }
            }
        }
    }
}

 运行结果如图，灰姑凉锁了口红，想要得到镜子；老巫婆锁了镜子，想要得到口红，于是互相僵持，形成死锁。

 解决方案很简单，由于上面的代码是嵌套的锁（synchronized），只要不进行嵌套就可以了，即分别给Mirror和LipsStick加锁即可：

运行结果正常：

4）Lock（锁）

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

package edu.ncu.dong.Thread.synchrnd;

import java.util.concurrent.locks.ReentrantLock;

/**
 * 测试Lock(锁)
 */
public class TestLock {
    public static void main(String[] args) {
        MyLock myLock=new MyLock();
        new Thread(myLock).start();
        new Thread(myLock).start();
        new Thread(myLock).start();
    }
}
class MyLock implements Runnable{
    int tickets=10;
    boolean flag=true;

    //定义可重入锁
    private final ReentrantLock lock=new ReentrantLock();
    @Override
    public void run() {
        while (flag){
            lock.lock();//加锁，这个锁的操作内容最好放在try-catch里面
            try{
                if(tickets<=0){
                    flag=false;
                    break;
                }
                System.out.println("tickets="+tickets--);
            }catch (Exception e){
                e.printStackTrace();
            }
            finally {
                lock.unlock();//解锁
            }
            //模拟延时
            try {
                Thread.sleep(1*1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

 运行结果，没有问题

 5）线程通信

常用的方法：

 注意:均是Object类的方法，都只能在同步方法或者同步代码块中使用,否则会抛出异常egalMonitorStateException（所有对象都能看到这些方法）

 生产者消费者问题：管程法（利用缓冲区的方法）

package edu.ncu.dong.Thread.communication;

/**
 * 生产者消费者模型
 * 方法一：利用缓冲区解决--管程法
 */
public class TestProducerAndConsumer {
    public static void main(String[] args) {
        Container container=new Container();
        new Producer(container).start();
        new Consumer(container).start();
    }
}

/*
生产者
 */
class Producer extends Thread{
    Container container;

    public Producer(Container container){
        this.container=container;
    }
    //生产
    @Override
    public void run() {
        for (int i=0;i<50;i++){
            System.out.println("生产者生产了第"+i+"只鸡");
            container.push(new Product(i));
        }
    }
}

/*
消费者
 */
class Consumer extends Thread{
    Container container;

    public Consumer(Container container){
        this.container=container;
    }
    //消费
    @Override
    public void run() {
        for (int i=0;i<50;i++){
            System.out.println("消费者消费了第"+container.pop().id+"只鸡");
        }
    }
}

/*
产品
 */
class Product{
    int id;//产品id

    public Product(int id) {
        this.id = id;
    }
}
/*
缓冲区
 */
class Container{

    //缓冲区大小
    Product[] productContainer =new Product[10];
    //当前应该放的位置
    int curPosition=0;

    //生产者放入缓冲区
    public synchronized void push(Product product){
        //如果容器满了，需要等待消费者消费
        if (curPosition>=productContainer.length){
            try{
                this.wait();//等待
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        //如果容器没有满，可以放入产品
        productContainer[curPosition]=product;
        curPosition++;
        this.notifyAll();//唤醒消费者消费
    }
    //消费者消费缓冲区内容
    public synchronized Product pop(){
        //缓冲区空了，需要等待生产者放入
        if (curPosition==0){
            try{
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        //缓冲区没空，可以进行消费
        curPosition--;
        Product product = productContainer[curPosition];
        this.notifyAll();//消费了一个，有空位置了，可以唤醒了生产者生产了
        return product;
    }

}

运行结果：没有问题

 6）线程池

◆JDK 5.0起提供了线程池相关API: ExecutorService 和Executors
◆ExecutorService:真正的线程池接口。常见子类ThreadPoolExecutor
        ◆void execute(Runnable command) :执行任务/命令,没有返回值，一般用来执行Runnable
        ◆<T> Future<T> submit(Callable<T> task):执行任务，有返回值，一 般又来执行Callable
        ◆void shutdown() :关闭连接池
◆Executors: 工具类、线程池的工厂类，用于创建并返回不同类型的线程池

看例子：

package edu.ncu.dong.Thread.pool;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

/**
 * 线程池
 */
public class TestPool {
    public static void main(String[] args) {
        //1.创建线程池
        ExecutorService service= Executors.newFixedThreadPool(10);//池子大小为10
        //2.执行线程
        service.execute(new MyThread());
        service.execute(new MyThread());
        service.execute(new MyThread());
        service.execute(new MyThread());
        //3.关闭连接
        service.shutdownNow();
    }
}
class MyThread implements Runnable{
    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            System.out.println(Thread.currentThread().getName());
        }
    }
}

 查看结果，跟平时用start()运行没什么不同

 类似于Callable，前面讲的线程创建方法的第三种：

 更加高级的内容需要学习JUC（并发）