云社区 博客 博客详情
云社区 博客 博客详情

Java并发编程:线程和锁的使用与解析

Winniebear 发表于 2020-05-19 18:50:05 05-19 18:50
Winniebear 发表于 2020-05-19 18:50:05 2020/05/19
0
0

【摘要】 线程的使用  新建线程  新建一个线程有两种方法:继承Thread类,然后重写run方法;实现Runnable接口,然后实现run方法。实际上Thread类也是实现的Runnable接口,再加上类只能单继承,所以推荐使用Runnable接口。示例如下: classDemo1implementsRunnable{@Overridepublicvoidrun(){//新建线程需要执...

线程的使用

  新建线程

  新建一个线程有两种方法:继承Thread类,然后重写run方法;实现Runnable接口,然后实现run方法。实际上Thread类也是实现的Runnable接口,再加上类只能单继承,所以推荐使用Runnable接口。示例如下:

 

class Demo1 implements Runnable{
    @Override
    public void run() {
        //新建线程需要执行的逻辑
    }
}

 

class Demo2 extends Thread{
    @Override
    public void run() {
        //新建线程需要执行的逻辑
    }
}

  对于Thread类,当然可以使用匿名内部类来简化写法:

Thread thread=new Thread(){
    public void run(){
        //新建线程需要执行的逻辑
    }
};
//Lambda表达式简化后
Thread thread=new Thread(()->{
    //需要执行的逻辑
});

新建完一个线程后,就可以用对象实例来启动线程,启动后就会执行我们重写后的run方法:

thread.start();

  此外,Thread类有个非常重要的构造方法:

public Thread(Runnable target) {
    init(null, target, "Thread-" + nextThreadNum(), 0);
}

  可见,传入的是一个Runnable类型的参数。为什么需要这个构造函数?因为Runnable接口只有一个run方法,如果我们直接实例化实现了这个接口的类,然后调用run方法,其实就和普通的类没有区别,并没有另外一个线程去执行run方法。说白了,Runnable并不是新建了一个线程,而只是线程里面执行任务的一种类型。在Java并发编程里,我们总是说的任务,很多时候就是Runnable类型的。所以我们还是需要把实现了Runnable接口的类的实例传入Thread的构造函数,然后通过start方法去调用Runnable的run方法。

//新建一个任务(Demo1实现了Runnable接口)
Demo1 task=new Demo1;
//新建一个线程并传入需要执行的任务
Thread thread=new Thread(task);
//启动线程执行任务
thread.start();

  线程的其他方法

  熟悉了线程的创建,再简单了解一下操作线程的其他方法。

  stop方法:作用是终止线程,但不推荐使用,因为它是强制结束线程,不管线程执行到了哪一步,很容易造成错误数据,引起数据不一致的问题。

  interrupt方法:作用和stop类似,但是并不会那么粗鲁的终止线程,如果只调用这一个方法并不会中断线程,它还需要配合一个方法使用:

class Demo implements Runnable {
    @Override
    public void run() {
        //通过isInterrupted方法判断当前线程是否需要停止,不需要停止就执行逻辑代码
        while (!Thread.currentThread().isInterrupted()){
            //逻辑
        }
    }
}
public class Use {
    public static void main(String[] args) throws InterruptedException {
        Demo task = new Demo ();
        Thread thread=new Thread(task);
        thread.start();
        //通知thread可以终止了
        thread.interrupt();
    }
}

  wait方法和notify方法:这两个方法放在一起说,是因为它们需要配合使用。简单提一下synchronized ,这个会在在锁里面讲。synchronized大概的作用就是:代码块里的代码,同时只能由一个线程去执行,如何确保只有一个线程去执行?谁拥有锁谁就有资格执行。任何对象都可以调用wait方法,如obj.wait,它的意思就是让当前线程在obj上等待并释放当前线程占用的锁。obj.notify就是唤醒在obj上等待的线程并重新尝试获取锁。下面演示一下简单的使用:

public class Use {
    //一定要确保等待和唤醒是同一个对象,用类锁也可以,至于什么是类锁可以看后面synchronized部分
    static Object object=new Object();
    static int i = 0;
    static class Demo1 implements Runnable {
        @Override
        public void run() {
            synchronized (object){
                for(int j=0;j<10000;j++){
                    i++;
                    if(i==5000){
                        //1.因为t1先启动并进入同步代码块,所以首先输出5000
                        System.out.println();
                        try {
                            //释放锁并等待
                            object.wait();
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                }
                //3.被唤醒后接着执行完剩余的代码,输出20000
                System.out.println(i);
            }
        }
    }
    static class Demo2 implements Runnable{
        @Override
        public void run() {
            synchronized (object){
                for(int j=0;j<10000;j++){
                    i++;
                }
                //2.获取到t1释放的锁,执行完代码后输出15000并唤醒object上等待的线程
                System.out.println(i);
                object.notify();
            }
        }
    }

    public static void main(String[] args) throws InterruptedException {
        Demo1 task1 = new Demo1();
        Demo2 task2 = new Demo2();
        Thread thread1=new Thread(task1);
        Thread thread2=new Thread(task2);
        thread1.start();
        thread2.start();
    }
}

  需要注意的是,如果有多个线程在obj等待,只执行一次obj.notify的话,它是随机从obj等待列表中选择一个线程唤醒的,如果要唤醒所有等待线程,可以使用obj.notifyAll不管wait、notify还是notifyAll只能在synchronized代码块中使用,否则会报IllegalMonitorStateException异常。Java之所以这么规定,是确保不会发生Lost Wake Up问题,也就是唤醒丢失。上面那个例子中使用了同步代码块,所以不会发生这种问题。试想一种情况,如果没有synchronized确保线程是有秩序执行的,当t2线程先唤醒了object上的对象,t1线程后暂停的,那么t1是不是就永远会暂停下去,t2notify相当于丢失了,这就是Lost wake up

  join方法:作用是让指定线程加入当前线程。为了节约篇幅还是以interrupt方法的代码为例,如果在main方法里调用thread.join(),那么主线程就会等待thread线程执行完才接着执行。其实这就和单线程的效果差不多了。如果有时候thread线程执行时间太长,为了不影响其他线程,我们可以在join方法里传入一个时间,单位是毫秒,当过了这个时间不管thread线程有没有执行完,主线程都会接着执行。join方法其实是通过wait方法实现的,注意这个wait是被加入线程等待,而不是加入的线程等待。贴一下源码,逻辑很简单就不复述了,如果join不传入参数,millis默认就是0:

public final synchronized void join(long millis)
throws InterruptedException {
    long base = System.currentTimeMillis();
    long now = 0;
    if (millis < 0) {
        throw new IllegalArgumentException("timeout value is negative");
    }
    if (millis == 0) {
        while (isAlive()) {
            wait(0);
        }
    } else {
        while (isAlive()) {
            long delay = millis - now;
            if (delay <= 0) {
                break;
            }
            wait(delay);
            now = System.currentTimeMillis() - base;
        }
    }
}

  yield方法:这个方法会让出当前线程的CPU,让出后还会接着去争夺,但是还能不能争夺到就不一定了。一般优先级比较低的线程,为了节约资源可以适当调用这个方法。

 

线程安全

  如何保证线程安全?无非就是锁的争夺。谁拥有了锁,谁才有资格执行。为什么只让一个线程执行代码?这就与Java的内存模型有关了。不了解的可以看其他资料,也可以看看我的另外一篇博客:https://www.cnblogs.com/lbhym/p/12458990.html,最后一节就是讲Java内存模型的。简单的说:线程共享的资源是放在一个共享内存区域的。当线程A去操作一个共享变量时,它会先把这个变量拷贝到自己私有的内存空间,然后进行操作,最后把操作后的值赋值到共享内存中的变量。如果在赋值之前另外一个线程B刚刚更新了这个值,那么线程A的操作就把线程B的操作给覆盖了,而线程B浑然不知,接着执行它的逻辑,这就造成了数据不一致的情况。所以我们必须加上一把锁,确保同一时间只能由一个线程来修改这个变量。

  关键字synchronized

  关键字synchronized的作用前面已经提到过了,下面给个简单的示例:

class Demo implements Runnable {
    static int i = 0;
    @Override
    public void run() {
        //小括号中的Demo.class就是锁,大括号内的代码同时只能由一个线程执行
       synchronized (Demo.class){
           for(int j=0;j<10000;j++) {
               i++;
           }
       }
    }

}
public class Use {
    public static void main(String[] args) throws InterruptedException {
        Demo task = new Demo();
        Thread thread1=new Thread(task);
        Thread thread2=new Thread(task);
        thread1.start();
        thread2.start();
        //让两个线程加入主线程,这样就可以输出执行后的i了
        thread1.join();
        thread2.join();
        System.out.println(Demo.i);//输出20000,如果去掉同步代码块,i绝对小于20000
    }
}

  其实这个关键字的作用很好理解,关键在于,小括号里面有什么实际意义,它与Lock有什么区别?

  首先synchronized和Lock都是Java里面的锁机制,前者用起来更加方便,后者功能更多。方便在哪?进入代码块前自动获取锁,如果锁已经被占,则会等待。执行完同步代码块中的内容,自动释放锁。而Lock需要手动加锁解锁,接下来会讲。

  接着说说synchronized具体用法,小括号里就是锁对象。有一点需要注意,synchronized锁的是对象,而不是里面的代码,谁拥有指定的锁谁就能执行里面的代码。明白这一点有助于理解下面的内容。

  synchronized的锁分为类锁和对象锁。它们的区别就是作用域的不同。

  首先说说对象锁怎么用以及它的特点:

//对象锁:
synchronized(this){...}
synchronized(类的实例){...}
//修饰在void前也是对象锁
public synchronized void run(){...}

  如果synchronized里指定的是对象锁,那么在创建task时,不同的实例对象就是不同的锁。大家可以在上面示例代码的基础上,再用Demo类实例化一个task2,然后用thread去执行它,接着把synchronized小括号里的锁换成this,也就是对象锁,会发现输出的i小于20000。因为tasktask2完全就是不同的锁,两个线程并不冲突,这就是为什么上面强调,锁的是对象,而不是里面的代码。

  再说说类锁的用法和特点:

//类锁
synchronized(类名.class){...}
//修饰在静态方法前也是类锁,run方法里直接调用handler就行
private synchronized static void handler(){...}

  上面的示例代码就是一个类锁,即使实例化两个不同的对象,提交给两个线程执行后,输出结果肯定是20000,也就是说它们是同步的。

  最后说一点,同一个类中,类锁和对象锁依旧是不同的锁,它们之间互不干扰,不是同步的。举个例子:

class Demo implements Runnable {
    static int i = 0;
    @Override
    public void run() {
          run2();
          run3();
    }
    //类锁
    private synchronized static void run2(){
        for(int j=0;j<10000;j++) {
            i++;
        }
    }
    //对象锁
    private synchronized void run3(){
        for(int j=0;j<10000;j++) {
            i++;
        }
    }
}

  main方法就不贴了,记得实例化一个task2给thread2执行。最后的输出结果肯定小于40000,如果把run3改成静态方法,也就是变成类锁,输出结果就是40000了。

   接口Lock

  Lock接口下提供了一套功能更完整的锁机制。如果项目中线程的竞争并不激烈,使用synchronized完全足够,如果竞争很激烈,还需要其他一些功能,这时候就可以尝试一下Lock提供的锁了。

  ReentrantLock:可重入锁

  简单的示例如下,说明也在注释当中:

class ReenterLock implements Runnable {
    //可重入锁,意思是:在同一个线程中,可以对lock多次加锁,当然也必须解锁对应次数
    //那么Lock下的锁是类锁还是对象锁,取决于锁对象是类变量还是普通的全局变量,加上static就是类锁,反之就是对象锁
    static ReentrantLock lock = new ReentrantLock();
    static int i = 0;
    @Override
    public void run() {
        lock.lock();
        for (int j=0;j<10000;j++){
            i++;
        }
        lock.unlock();
    }
}
public class 可重入锁 {
    public static void main(String[] args) throws InterruptedException {
        ReenterLock task = new ReenterLock();
        Thread thread1=new Thread(task);
        Thread thread2=new Thread(task);
        thread1.start();
        thread2.start();
        thread1.join();
        thread2.join();
        System.out.println(ReenterLock.i);
    }
}

  可重入锁除了以上加锁、解锁的基本功能外,还有其他一些功能:

  lockInterruptibly方法和interrupt方法:后者在线程中已经出现过一次了,虽然名字一样,功能也差不多,但是作用对象不一样。如果我们的线程在加锁也就是获取锁时,用的是lockInterruptibly方法,如果在等待一段时间后,还没获取到锁,那么就可以通过interrupt方法通知这个线程不用等了。这两个方法配合使用,在设置合理的等待时间后,可以避免死锁的发生。但需要注意,被通知放弃获取锁的线程会释放自己的资源,结束执行任务。

  tryLock方法:除了上面那种外部通知放弃获取锁的方法外,还有一种限时等待的方法,tryLock有两个参数,第一个是时间,第二个是时间类型。如果不传入任何参数,获取到锁直接返回true,没获取到直接返回false。对的,tryLock和普通的lock方法不同,它返回的是Boolean类型,所以一般需要配合if判断使用:

@Override
public void run() {
    try {
        if (lock.tryLock(10, TimeUnit.SECONDS)) {
            //逻辑代码
        }
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
}

  公平锁和非公平锁:公平锁的分配是公平的,先到先得。非公平锁则是随机分配锁的,你先等待的不一定能先获取到锁。具体的是在ReenterLock构造函数中进行设置:

//构造函数传入true就是公平锁,默认情况下是非公平锁
static ReentrantLock lock = new ReentrantLock(true);

  默认情况下采用非公平锁,是因为公平锁需要维护一个有序队列,性能相较于非公平锁是非常低的。

 

  Condition:可重入锁的搭档

  在synchronized代码块中,可以使用wait方法让当前线程释放锁并等待,然后通过notify方法唤醒线程并尝试重新获取锁。但是这两个方法是作用在synchronized中的,前面也说过了。在可重入锁也有类似的功能,下面举个简单的例子,会发现和synchronized中的wait和notify差不都:

public class Use {
    static ReentrantLock lock = new ReentrantLock();
    //创建的lock的condition对象
    static Condition condition = lock.newCondition();
    static int i = 0;
    static class Demo1 implements Runnable {
        @Override
        public void run() {
            //t1先进来加锁(遇到一次特殊情况,t2后启动的反而先获取到锁了)
            lock.lock();
            for (int j = 0; j < 10000; j++) {
                i++;
                if (i == 5000) {
                    //1.输出5000
                    System.out.println(i);
                    try {
                        //释放锁并等待
                        condition.await();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
            //被唤醒后接着执行完剩下的代码,并输出20000
            System.out.println(i);
            lock.unlock();
        }
    }
    static class Demo2 implements Runnable {
        @Override
        public void run() {
            //获取锁
            lock.lock();
            for (int j = 0; j < 10000; j++) {
                i++;
            }
            System.out.println(i);
            //2.执行完后输出15000,并唤醒等待的线程
            condition.signal();
            lock.unlock();
        }
    }

    public static void main(String[] args) throws InterruptedException {
        Demo1 task1 = new Demo1();
        Demo2 task2 = new Demo2();
        Thread thread1 = new Thread(task1);
        Thread thread2 = new Thread(task2);
        thread1.start();
        thread2.start();
    }
}

  await方法会使当前线程等待,同时释放当前锁,当其他线程中使用signal()方法或者signalAll()方法时,线程会重新获得锁并继续执行。或者当线程被中断时,也能跳出等待。这和Object.wait()方法相似。

  awaitUninterruptibly方法与await方法基本相同,但是它并不会在等待过程中响应中断。

  singal方法用于唤醒一个在等待中的线程,singalAll方法会唤醒所有在等待中的线程。这和Obejct.notify()方法很类似。

 

  Semaphore:允许多个线程同时访问

  前面提到的可重入锁和同步代码块一次只能让一个线程进入,而Semaphore可以指定多个线程,同时访问一个资源。

public class Use {
    static int i = 0;
    //一次允许两个线程进入
    static Semaphore sema = new Semaphore(2);
    static class Demo2 implements Runnable {
        @Override
        public void run() {
            try {
                //如果有多余的名额就允许一个线程进入
                sema.acquire();
                for(int j=0;j<10000;j++){
                    i++;
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }finally {
                //当前线程执行完代码并释放一个名额
                sema.release();
            }
        }
    }

    public static void main(String[] args) throws InterruptedException {
        //Demo1 task1 = new Demo1();
        Demo2 task2 = new Demo2();
        Thread thread1 = new Thread(task2);
        Thread thread2 = new Thread(task2);
        thread1.start();
        thread2.start();
        thread1.join();
        thread2.join();
        System.out.println(i);//输出小于20000,说明同时有两个线程进去了,互相干扰了。
    }
}

  

  ReadWriteLock:读写锁

  很多时候线程只是执行读操作,并不会互相干扰,其实这个时候并不需要线程之间相互排斥。在数据库里面读写锁是比较常见的,在Java中,它们的逻辑其实是一样的。只有读和读不会阻塞,有写操作必然阻塞。

代码篇幅太多了,就不再演示逻辑代码了,下面是读写锁的创建代码:

static ReentrantReadWriteLock readWriteLock=new ReentrantReadWriteLock();
//读锁
static Lock readLock=readWriteLock.readLock();
//写锁
static Lock writLock=readWriteLock.writeLock();

  

  CountDownLatch:倒计数器

  一个实用的多线程工具类,说倒计数器可能有点不明白,其实就是等来指定数量的线程执行完后才执行接下来的代码,看示例更清楚:

public class Use {
    //需要两个线程执行完任务
    static CountDownLatch count = new CountDownLatch(2);
    static int i=0;
    static class Demo2 implements Runnable {
        @Override
        public void run() {
            synchronized (Use.class) {
                for (int j = 0; j < 10000; j++) {
                    i++;
                }
                //当前线程执行完任务,计数器+1
                count.countDown();
            }
        }
    }

    public static void main(String[] args) throws InterruptedException {
        //Demo1 task1 = new Demo1();
        Demo2 task2 = new Demo2();
        Thread thread1 = new Thread(task2);
        Thread thread2 = new Thread(task2);
        thread1.start();
        thread2.start();
        //等待指定数量的线程都执行完任务后才接着执行,相当于阻塞了当前的主线程,从而实现了join的功能
        count.await();
        System.out.println(i);//输出20000
    }
}

 

文章来源: www.cnblogs.com,作者:耶low,版权归原作者所有,如需转载,请联系作者。

原文链接:https://www.cnblogs.com/lbhym/p/12913280.html

登录后可下载附件,请登录或者注册

【版权声明】本文为华为云社区用户转载文章,如果您发现本社区中有涉嫌抄袭的内容,欢迎发送邮件至:huaweicloud.bbs@huawei.com进行举报,并提供相关证据,一经查实,本社区将立刻删除涉嫌侵权内容。
评论文章 //点赞 收藏 0
点赞
分享文章到微博
分享文章到朋友圈

评论 (0)


0/1000
评论

登录后可评论,请 登录注册

评论

您还没有写博客的权限!

温馨提示

您确认删除评论吗?

确定
取消
温馨提示

您确认删除评论吗?

删除操作无法恢复,请谨慎操作。

确定
取消
温馨提示

您确认删除博客吗?

确定
取消

确认删除

您确认删除博客吗?

确认删除

您确认删除评论吗?

温馨提示

登录超时或用户已下线,请重新登录!!!

确定
取消