Java多线程JUC

1. volatile 关键字

多线程访问的时候,一个比较严重的问题就是内存不可见,其实在内存访问的时候每一个线程都有一个自己的缓冲区,每次在做修改的时候都是从主存取到数据,然后放到自己的缓冲区中,在做完修改之后放回主存。这样每一个线程之间的变量是不可见的。造成读到的数据可能始终就是错误的,因此有一个关键字可以使得这个共享变量称为透明的。就好像所有的操作就直接是在内存中操作一样,因为他一直不停的去同步主存的数据。

2.原子性

i++ 这个运算,其实在底层低用的就是临时变量的方式,这样的话虽然是一个表达式,但是在多线程的时候就会出现安全问题。

package atomic;

/**
 * @Author: lwen
 * @Date: Created in 2017/8/19 15:26
 * @Description:
 */

class Test implements Runnable{
    private volatile int i=0;
    @Override
    public void run() {
        try {
            Thread.sleep(200);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(i++);
    }
}
public class Main {
    public static void main(String[] args) {
        Test t=new Test();
        for (int i = 0; i < 10; i++) {
            new Thread(t).start();
        }
    }
}

最后运行的结果,显然就是 volatile 这个关键字他只是让变量课件也就是都是在主存中操作,但是他没有互斥的作用简单来说没有锁来控制,他们都及时的从主存里面拿到了数据,但是他们拿到最新的数据了,正在运算的时候有人提交了结果,所以导致重复元素。最根本原因是 i++ 有三步操作,读,运算,写

> 1 3 2 0 4 7 6 5 8 8 Process finished with exit code 0

java 底层提供了一些原子性的变量,例如 AtomicInteger 这些东西他们既然是源自的首先就是可见的。这些东西的底层主要是使用了 CAS ( CompareAndSet ) 算法,CAS 算法主要是操作系统在硬件上提供的支持。 这个算法有三个重要的参数:第一个就是 V 就是运算前从内存读取的值 A 写入前从内存中读取的值 B 最终需要写入的值。在写入前做一次判断当且仅当 V == A 时才会写入 B 否则什么操作也不做。

3.ConcurrentHahsMap 安全的 HashMap

这是一个线程安全的 HashMap ,说道线程安全的 HahsMap 自然就有 HashTable 但是这个效率非常的低,主要就是因为他的封锁粒度太大,他锁的是整个 HashTable 也就是两个不相干的 HashTable 也是互斥访问的,在 jdk1.5 以后使用的就是 ConcurrentHahsMap 这个东西那个时候主要使用的锁分段机制,也就是在原来的基础上把 HashTable 分16段,每一段对应一个 HashMap 这样的话两个互不相干的 HashMap 是可以同步访问的。

4.CountDownLatch 闭锁

所谓的闭锁说白了就是该线程会等到洽谈所有线程的代码都运行结束了才开始运行,他的底层实现就是维护一个变量,这个变量就是当前存活的线程的数量,当他减成0了也就是其他的线程都运行完了,此时这个闭锁线程可以开始。例如说我们开十个线程做某一件事情,我们在主线程中统计这十个线程的总的运行时间。

package latch;

import com.sun.javafx.sg.prism.web.NGWebView;

import java.util.concurrent.CountDownLatch;

/**
 * @Author: lwen
 * @Date: Created in 2017/8/19 16:06
 * @Description:
 */
class Latch implements Runnable{
    private CountDownLatch latch;

    public Latch(CountDownLatch latch) {
        this.latch = latch;
    }

    @Override
    public void run() {
        System.out.println(Thread.currentThread());
        try {
            Thread.sleep(10);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        latch.countDown();  //线程结束以后,需要给维护的变量减一
    }
}

public class Main {
    public static void main(String[] args) throws InterruptedException {
        int start= (int) System.currentTimeMillis();
        CountDownLatch downLatch= new CountDownLatch(10);  //定义十个线程
        Latch latch=new Latch(downLatch);
        for (int i = 0; i < 10; i++) {
            new Thread(latch).start();
        }
        downLatch.await();  //当线程没有完全结束的时候,主线程需要等待
        int end= (int) System.currentTimeMillis();
        System.out.println(end-start);
    }
}

4.线程的第三种创建方式

一般我们创建线程我们使用的都是继承 Thread 类,或者实现 Runnable 接口,但是还是主要使用的是实现 Runnable 接口,但是注意这两个方式他们嗾使没有返回值的东西。也就是我么不能多线程没有办法返回一些结果。这里就出现了创建线程的第三种方式,也就是可以得到返回值的方式,就是使用 Callable 接口,这个接口的使用需要使用 FutureTask 类,而这个类实现了 Runnable 和 Future 接口,他的具体的使用方式和 Runnable 接口还是有一点不一样的。

package future;

import org.omg.PortableInterceptor.INACTIVE;

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;

/**
 * @Author: lwen
 * @Date: Created in 2017/8/19 16:23
 * @Description:
 */
class Future implements Callable<Integer>{

    @Override
    public Integer call() throws Exception {
        int sum=0;
        for (int i = 0; i < 1000; i++) {
            sum+=i;
        }
        return sum;
    }
}

public class Main {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        Future future=new Future();
        FutureTask<Integer> task=new FutureTask<Integer>(future);
        new Thread(task).start();

        System.out.println(task.get());;//获取最终的返回值,但是注意这个地方的这个方法其实就是一个闭锁,前面的那个县城没有执行完,这个地方是不会执行的
    }
}

5.高级同步

解决同步问题总共就有三种方式,分别就是同步代码块,同步函数,和同步锁。 也就是手动的声明 lock 加锁,然后使用 unlock 释放锁

package lock;

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

/**
 * @Author: lwen
 * @Date: Created in 2017/8/19 16:33
 * @Description:
 */

class Ticket implements Runnable{
    private int ticket=100;
    Lock lock=new ReentrantLock();
    @Override
    public void run() {
        while (true) {
            lock.lock();
            try {
                if (ticket != 0) {
                    try {
                        Thread.sleep(20);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    ticket--;
                    System.out.println(Thread.currentThread().getName() + ":" + ticket);

                }
            }finally {
                lock.unlock();  //解锁必须放在finally里面保证能够执行到
            }
        }
    }
}

public class Main {
    public static void main(String[] args) {
        Ticket t=new Ticket();
        new Thread(t,"窗口一").start();
        new Thread(t,"窗口二").start();
        new Thread(t,"窗口三").start();
    }
}

6.生产者和消费者的线程同步问题

package product;

import java.util.logging.Level;

/**
 * @Author: lwen
 * @Date: Created in 2017/8/19 16:57
 * @Description:
 */
class Clerk {
    private int production=0;

    public synchronized void get() throws InterruptedException {
        while (production>=1){  //notifyAll 可能会形成假唤醒问题,所以说必须要使用while一直判断而不能使用if
            System.out.println("已满");
            this.wait();
        }
        System.out.println(Thread.currentThread().getName()+":"+ ++production);
        this.notifyAll();

    }

    public synchronized void sale() throws InterruptedException {
        while (production<=0){
            System.out.println("卖完");
            this.wait();
        }
        System.out.println(Thread.currentThread().getName()+":"+ --production);
        this.notifyAll();

    }
}


class Product implements Runnable{
    private Clerk clerk;

    public Product(Clerk clerk) {
        this.clerk = clerk;
    }

    @Override
    public void run() {
        for (int i = 0; i < 20; i++) {
            try {
                Thread.sleep(20);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            try {
                clerk.get();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

class Consumer implements Runnable{
    private Clerk clerk;

    public Consumer(Clerk clerk) {
        this.clerk = clerk;
    }

    @Override
    public void run() {
        for (int i = 0; i < 20; i++) {
            try {
                Thread.sleep(20);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            try {
                clerk.sale();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}
public class Main {
    public static void main(String[] args) {
        Clerk clerk=new Clerk();
        Product p=new Product(clerk);
        Consumer consumer=new Consumer(clerk);
        new Thread(p,"生产者1").start();
        new Thread(p,"生产者2").start();
        new Thread(consumer,"消费者1").start();
        new Thread(consumer,"消费者2").start();
    }
}

7.读写锁

排斥写写和读写同时进行

package readandwrite;

import java.util.concurrent.locks.ReadWriteLock;
import java.util.concurrent.locks.ReentrantReadWriteLock;

/**
 * @Author: lwen
 * @Date: Created in 2017/8/19 17:29
 * @Description:
 */

class ReadWriteLockDemo {
    private int number=0;
    private ReadWriteLock lock=new ReentrantReadWriteLock();

    public void read(){
        lock.readLock().lock();
        try {
            System.out.println(Thread.currentThread().getName()+":"+number);
        }finally {
            lock.readLock().unlock();
        }
    }

    public void write(int number) throws InterruptedException {
        lock.writeLock().lock();
        Thread.sleep(20);
        try {
            this.number=number;
            System.out.println("write");
        }finally {
            lock.writeLock().unlock();
        }
    }
}

public class Main {
    public static void main(String[] args) {
        ReadWriteLockDemo readWriteLockDemo=new ReadWriteLockDemo();
        new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    readWriteLockDemo.write(20);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }).start();

        for (int i = 0; i < 20; i++) {
            new Thread(new Runnable() {
                @Override
                public void run() {
                    readWriteLockDemo.read();
                }
            }).start();
        }
    }
}

4.线程池

package pool;

import java.util.concurrent.*;

/**
 * @Author: lwen
 * @Date: Created in 2017/8/19 17:56
 * @Description:
 */

class Test implements Runnable{

    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName());
    }
}


class Test1 implements Callable<Integer>{

    @Override
    public Integer call() throws Exception {
        int sum=0;
        for (int i = 0; i <= 100; i++) {
            sum+=i;
        }
        return sum;
    }
}
public class Main {
    public static void main(String[] args) throws ExecutionException, InterruptedException {

        //注意线程池里面装的都是线程,这些线程到时候再次使用的时候不需要再次创建,也就是代表操作系统不需要再次分配资源,分配pid等等
        //而不是说里面装的是任务,这里仅仅就是线程而已
        ExecutorService executor= Executors.newFixedThreadPool(10);  //固定大小的线程池
        ExecutorService executor1=Executors.newSingleThreadExecutor(); //一个线程的线程池
        ExecutorService executor2=Executors.newCachedThreadPool(); //动态变化的线程池
        for (int i = 0; i < 20; i++) {
            executor.submit(new Test());
        }

        Future<Integer> future=executor1.submit(new Test1());
        System.out.println(future.get());

        executor.shutdown(); //只有当线程池关闭的时候  程序才会停止
        executor1.shutdown();
        executor2.shutdown();
    }
}

8.线程调度:

线程调度可以决定在多久之后执行什么操作。

package schedule;

import java.util.Random;
import java.util.concurrent.*;

/**
 * @Author: lwen
 * @Date: Created in 2017/8/19 18:11
 * @Description:
 */


public class Main {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        ScheduledExecutorService service= Executors.newScheduledThreadPool(5);
        for (int i = 0; i < 5; i++) {
            Future<Integer> future=service.schedule(new Callable<Integer>() {
                @Override
                public Integer call() throws Exception {
                    int random=new Random().nextInt(100);
                    System.out.println(Thread.currentThread().getName()+":"+random);
                    return random;
                }
            },1, TimeUnit.SECONDS);
            System.out.println(future.get());
        }
        service.shutdown();
    }
}

本文参与腾讯云自媒体分享计划,欢迎正在阅读的你也加入,一起分享。

我来说两句

0 条评论
登录 后参与评论

相关文章

  • 并查集

    ​ 在我们需要判断某一些事物之间是否存在一定的关系的时候,我们最好的办法不是使用图而是使用并查集。因为我们关心的是他们之间是否有关系,而不是关心的他们到底...

    lwen
  • 归并排序

    归并排序是建立在归并操作上的一种有效的排序算法。该算法是采用分治法(Divide and Conquer)的一个非常典型的应用。 首先考虑下如何将将二个有序数列...

    lwen
  • Java多线程

    1.复写run方法的目的在于,把要运行的代码放到run方法里面,也就是新的线程要跑什么内容 这也就是第一种多线程的方法,其主要的步骤如下: 继承Thread类 ...

    lwen
  • 编写高性能的Java代码需要注意的4个问题

    ThreadLocalMap使用ThreadLocal的弱引用作为key,如果一个ThreadLocal没有外部强引用来引用它,那么系统 GC 的时候,这个Th...

    宜信技术学院
  • 线程同步

    mathor
  • JUC 多线程基础

    如果一个线程对共享变量的修改,能够被其它线程看到,那么就能说明共享变量在线程之间是可见的。如果一个变量在多个线程的工作内存中都存在副本,那么这个变量就是这几个线...

    万能青年
  • SurfaceView播放视频发送弹幕并实现滚动歌词

    本文实例为大家分享了SurfaceView播放视频发送弹幕,并实现滚动歌词,供大家参考,具体内容如下

    砸漏
  • (68) 线程的基本协作机制 (下) / 计算机程序的思维逻辑

    本节继续上节的内容,探讨如何使用wait/notify实现更多的协作场景。 同时开始 同时开始,类似于运动员比赛,在听到比赛开始枪响后同时开始,下面,我们模拟...

    swiftma
  • Java网络编程的Java流介绍

    网络程序所做的很大一部分工作都是简单的输入输出:将数据字节从一个系统移动到另一个系统。Java的I/O建立于流(stream)之上。输入流读取数据,输出流写入数...

    纪莫
  • java 线程之对象的同步和异步(实例讲解)

    下面小编就为大家带来一篇java 线程之对象的同步和异步(实例讲解)。小编觉得挺不错的,现在就分享给大家,也给大家做个参考。一起跟随小编过来看看吧

    挨踢小子部落阁

扫码关注云+社区

领取腾讯云代金券