Java并发基础-线程间通信

简介: Java并发基础-线程间通信

线程间通信

volatile和synchronized关键字

volatile修饰的变量,程序访问时都需要在共享内存中去读取,对它的改变也必须更新共享内存,保证了线程对变量访问的可见性。

synchronized:对于 同步块 的实现使用了monitorenter和monitorexit指令,而 同步方法 则是依靠方法修饰符上的ACC_SYNCHRONIZED来完成的。无论采用哪种方式,其本质是对一个对象的监视器monitor进行获取,而这个获取过程是排他的,也就是同一时刻只能有一个线程获取到由synchronized所保护对象的监视器。

等待/通知机制——wait和notify

指一个线程A调用了对象O的wait()方法进入等待状态,而另一个线程B调用了对象O的notify()或者notifyAll()方法,线程A收到通知后从对象O的wait()方法返回,进而执行后续操作。 等待:wait()、wait(long)、wait(long, int) 通知:notify()、notifyAll() 示例:

    private static Object object = new Object();

    public static void main(String[] args) throws InterruptedException {
        Thread t1 = new Thread(() -> {
            try {
                TimeUnit.SECONDS.sleep(1);
                synchronized (object) {
                    System.out.println("t1 start object.wait(), time = " + System.currentTimeMillis() / 1000);
                    object.wait();
                    System.out.println("t1 after object.wait(), time = " + System.currentTimeMillis() / 1000);
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });
        Thread t2 = new Thread(() -> {
            try {
                TimeUnit.SECONDS.sleep(5);
                synchronized (object) {
                    System.out.println("t2 start object.notify(), time = " + System.currentTimeMillis() / 1000);
                    object.notify();
                    System.out.println("t2 after object.notify(), time = " + System.currentTimeMillis() / 1000);
                }

                synchronized (object) {
                    System.out.println("t2  hold lock again, time = " + System.currentTimeMillis() / 1000);
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });
        t1.start();
        t2.start();
    }
复制代码

输出的结果

t1 start object.wait(), time = 1560138112
t2 start object.notify(), time = 1560138116
t2 after object.notify(), time = 1560138116
t2  hold lock again, time = 1560138116
t1 after object.wait(), time = 1560138116
复制代码

以下结论

  1. wait()、notify()和notifyAll()时需要先对调用对象加锁,否则会报java.lang.IllegalMonitorStateException异常。
  2. 调用wait()方法后,线程状态由RUNNING变为WAITING,并将当前线程放置到对象的等待队列。
  3. notify()或notifyAll()方法调用后,等待线程依旧不会从wait()返回,需要调用notify()或notifAll()的线程释放锁之后,等待线程才有机会从wait()返回。
  4. notify()方法将等待队列中的一个等待线程从等待队列中移到同步队列中,而notifyAll()方法则是将等待队列中所有的线程全部移到同步队列,被移动的线程状态由WAITING变为BLOCKED。
  5. 从wait()方法返回的前提是获得了调用对象的锁。

等待/通知的经典范式

包括 等待方(消费者)和 通知方(生产者)。 等待方遵循以下原则:

  • 获取对象的锁。
  • 如果条件不满足,那么调用对象的wait方法,被通知后任要检查条件。
  • 条件不满足则执行对应的逻辑。 对应代码如下:
synchronized (对象) {
    while (条件不满足) {
        对象.wait();
    }
    对应的处理逻辑
}
复制代码

通知方遵循以下原则:

  • 获取对象的锁。
  • 改变条件。
  • 通知所有在等待在对象上的线程。
synchronized (对象) {
    改变条件
    对象.notifyAll();
}
复制代码

管道输入/输出流

PipedWriter和PipedReader分别是字符管道输出流和字符管道输入流,是字符流中"管道流",可以实现同一个进程中两个线程之间的通信,与PipedOutputStream和PipedInputStream相比,功能类似.区别是前者传输的字符数据,而后者传输的是字节数据.

不同线程之间通信的流程大致是:PipedWriter与PipedReader流进行连接,写入线程通过将字符管道输出流写入数据,实际将数据写到了与PipedWriter连接的PipedReader流中的缓冲区,然后读取线程通过PipedReader流读取之前存储在缓冲区里面的字符数据.

例子

    private static PipedWriter writer;
    private static PipedReader reader;

    public static void main(String[] args) throws InterruptedException, IOException {
        writer = new PipedWriter();
        reader = new PipedReader();
        //绑定输入输出
        writer.connect(reader);
        Thread t = new Thread(() -> {
            int res;
            try {
                while ((res = reader.read()) != -1) {
                    System.out.print((char) res);
                }
            } catch (Exception e) {
                e.printStackTrace();
            }
        });
        t.start();

        int res;
        while ((res = System.in.read()) != -1) {
            System.out.println(res);
            writer.write(res);
            //按回车结束
            if (res == 10) {
                break;
            }
        }
        writer.close();
    }
复制代码

ThreadLocal

变量值的共享可以使用public static的形式,所有线程都使用同一个变量,如果想实现每一个线程都有自己的共享变量该如何实现呢?JDK中的ThreadLocal类正是为了解决这样的问题。

ThreadLocal类并不是用来解决多线程环境下的共享变量问题,而是用来提供线程内部的共享变量,在多线程环境下,可以保证各个线程之间的变量互相隔离、相互独立。在线程中,可以通过get()/set()方法来访问变量。ThreadLocal实例通常来说都是private static类型的,它们希望将状态与线程进行关联。这种变量在线程的生命周期内起作用,可以减少同一个线程内多个函数或者组件之间一些公共变量的传递的复杂度。

例子

public class ThreadLocalTest {
  static class MyThread extends Thread {
    private static ThreadLocal<Integer> threadLocal = new ThreadLocal<>();
    
    @Override
    public void run() {
      super.run();
      for (int i = 0; i < 3; i++) {
        threadLocal.set(i);
        System.out.println(getName() + " threadLocal.get() = " + threadLocal.get());
      }
    }
  }
  
  public static void main(String[] args) {
    MyThread myThreadA = new MyThread();
    myThreadA.setName("ThreadA");
    
    MyThread myThreadB = new MyThread();
    myThreadB.setName("ThreadB");
    
    myThreadA.start();
    myThreadB.start();
  }
}
复制代码
ThreadA threadLocal.get() = 0
ThreadB threadLocal.get() = 0
ThreadA threadLocal.get() = 1
ThreadA threadLocal.get() = 2
ThreadB threadLocal.get() = 1
ThreadB threadLocal.get() = 2
复制代码

ThreadLocal最简单的实现方式就是ThreadLocal类内部有一个线程安全的Map,然后用线程的ID作为Map的key,实例对象作为Map的value,这样就能达到各个线程的值隔离的效果。

一个数据库连接池的简单实现

1.连接池创建

package com.atguigu.ct.producer.Test.BB;

import java.sql.Connection;
import java.util.LinkedList;

public class ConnectionPool {

    private LinkedList<Connection> pool = new LinkedList<>();

    public ConnectionPool(int initialSize){
        if(initialSize > 0){
            for (int i = 0; i < initialSize ; i++) {
                pool.addLast(ConnectionDriver.createConnection());
            }
        }
    }

    public void releaseConnection(Connection connection){
        if(connection != null){
            synchronized (pool){
                //连接释放后需要进行通知,这样其他消费者能够感知到连接池中已归还了一个连接
                pool.addLast(connection);
                pool.notifyAll();
            }
        }
    }

    //在 mills内无法获取到连接,将返回 null
    public Connection fetchConnection(long mills) throws InterruptedException {
        synchronized (pool){
            //完全超时
            if(mills <= 0){
                while (pool.isEmpty()){
                    pool.wait();
                }
                return pool.removeFirst();
            }else{
                long future = System.currentTimeMillis() + mills;
                long remaining = mills;
                while (pool.isEmpty() && remaining > 0){
                    pool.wait(remaining);
                    remaining = future - System.currentTimeMillis();
                }
                Connection result = null;
                if(!pool.isEmpty()){
                    result = pool.removeFirst();
                }
                return result;
            }
        }
    }
}

复制代码

2.由于java.sql.Connection 是一个接口,最终的实现是由数据库驱动提供方来实现的,博主只是为了娱乐,就用动态代理构造了一个Connection,改Connection的代理实现仅仅是在commit()方法调用时休眠100毫秒,如下

package com.atguigu.ct.producer.Test.BB;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.sql.Connection;
import java.util.concurrent.TimeUnit;

public class ConnectionDriver {

    static class ConnectionHandler implements InvocationHandler {

        @Override
        public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
            if(method.getName().equals("commit")){
                TimeUnit.MILLISECONDS.sleep(100);
            }
            return null;
        }
    }

    //创建一个 Connection 代理,在 commit 时休眠 100 毫秒
    public static final Connection createConnection(){
        return (Connection) Proxy.newProxyInstance(ConnectionDriver.class.getClassLoader(),
                new Class<?>[]{Connection.class}, new ConnectionHandler());
    }
}

复制代码

3.模拟客户端ConnectionRunner获取、使用、最后释放连接的过程,当他使用时连接将会增加获取到连接的数量,反之,将会增加未获取到连接的数量,如下:

package com.atguigu.ct.producer.Test.BB;

import java.sql.Connection;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.atomic.AtomicInteger;

public class ConnectionPoolTest {

    static ConnectionPool pool = new ConnectionPool(10);
    //保证所有的ConnectionRunner 能够同时开始
    static CountDownLatch start = new CountDownLatch(1);
    //main 线程将会等待所有 ConnectionRunner 结束才能继续执行
    static CountDownLatch end;

    public static void main(String[] args) throws InterruptedException {
        //线程数量,可以修改线程数量进行观察
        int threadCount = 100;
        end = new CountDownLatch(threadCount);
        int count = 20;
        AtomicInteger got = new AtomicInteger();
        AtomicInteger notGot = new AtomicInteger();
        for (int i = 0; i < threadCount; i++) {
            Thread thread = new Thread(new ConnetionRunner(count, got, notGot), "ConnetionRunnerThread");
            thread.start();
        }
        start.countDown();
        end.await();
        System.out.println("total invoke:" + (threadCount * count));
        System.out.println(" got connection : " + got);
        System.out.println(" not got connection : " + notGot);
    }


    static class ConnetionRunner implements Runnable {

        int count;
        AtomicInteger got;
        AtomicInteger notGot;

        public ConnetionRunner(int count, AtomicInteger got, AtomicInteger notGot) {
            this.count = count;
            this.got = got;
            this.notGot = notGot;
        }

        @Override
        public void run() {
            try {
                start.await();
            } catch (InterruptedException e) {
            }
            while (count > 0) {
                try {
                    //从线程池中获取连接,如果1000ms内无法获取到,将会返回null
                    //分别统计连接获取的数量got和未获取到的数量 notGot
                    Connection connection = pool.fetchConnection(1000);
                    if (connection != null) {
                        try {
                            connection.createStatement();
                            connection.commit();
                        } finally {
                            pool.releaseConnection(connection);
                            got.incrementAndGet();
                        }
                    } else {
                        notGot.incrementAndGet();
                    }
                } catch (Exception e) {
                    e.printStackTrace();
                } finally {
                    count--;
                }
            }
            end.countDown();
        }
    }
}

复制代码

下面通过使用前一节中的线程池来构造一个简单的Web服务器,这个Web服务器用来处理 HTTP请求,目前只能处理简单的文本和JPG图片内容。这个Web服务器使用main线程不断地接 受客户端Socket的连接,将连接以及请求提交给线程池处理,这样使得Web服务器能够同时处 理多个客户端请求,示例如下所示。

public class SimpleHttpServer {
 
    private int port=8080;
    private ServerSocketChannel serverSocketChannel = null;
    private ExecutorService executorService;
    private static final int POOL_MULTIPLE = 4;
 
    public SimpleHttpServer() throws IOException {
      executorService= Executors.newFixedThreadPool(
        Runtime.getRuntime().availableProcessors() * POOL_MULTIPLE);
      serverSocketChannel= ServerSocketChannel.open();
      serverSocketChannel.socket().setReuseAddress(true);
      serverSocketChannel.socket().bind(new InetSocketAddress(port));
      System.out.println("ddd");
    }
 
    public void service() {
      while (true) {
        SocketChannel socketChannel=null;
        try {
          socketChannel = serverSocketChannel.accept();
          executorService.execute(new Handler(socketChannel));
        }catch (IOException e) {
           e.printStackTrace();
        }
      }
    }
 
    public static void main(String args[])throws IOException {
      new SimpleHttpServer().service();
    }
    class Handler implements Runnable{
    private SocketChannel socketChannel;
    public Handler(SocketChannel socketChannel){
      this.socketChannel=socketChannel;
    }
    public void run(){
      handle(socketChannel);
    }
 
    public void handle(SocketChannel socketChannel){
      try {
          Socket socket=socketChannel.socket();
          System.out.println("ddd" +
          socket.getInetAddress() + ":" +socket.getPort());
 
           ByteBuffer buffer=ByteBuffer.allocate(1024);
           socketChannel.read(buffer);
           buffer.flip();
           String request=decode(buffer);
           System.out.print(request);  
 
           StringBuffer sb=new StringBuffer("HTTP/1.1 200 OK\r\n");
           sb.append("Content-Type:text/html\r\n\r\n");
           socketChannel.write(encode(sb.toString()));
 
           FileInputStream in;
           
           String firstLineOfRequest=request.substring(0,request.indexOf("\r\n"));
           if(firstLineOfRequest.indexOf("login.htm")!=-1)
              in=new FileInputStream("/Users/tokou/Documents/post.html");
           else
              in=new FileInputStream("/Users/tokou/Documents/post.html");
 
           FileChannel fileChannel=in.getChannel();
           fileChannel.transferTo(0,fileChannel.size(),socketChannel);
           fileChannel.close();
        }catch (Exception e) {
           e.printStackTrace();
        }finally {
           try{
             if(socketChannel!=null)socketChannel.close();
           }catch (IOException e) {e.printStackTrace();}
        }
    }
    private Charset charset=Charset.forName("GBK");
    public String decode(ByteBuffer buffer){  
      CharBuffer charBuffer= charset.decode(buffer);
      return charBuffer.toString();
    }
    public ByteBuffer encode(String str){  
      return charset.encode(str);
    }
   }
}

复制代码

面试题

2个线程交替打印A1B2C3D4...这样的模式的实现

方法一 LockSupport

public class TestLockSupport {

    static Thread t1=null,t2=null;

    public static void main(String[] args) {

        char[] aI="1234567".toCharArray();
        char[] aC="ABCDEFG".toCharArray();

        t1=new Thread(()->{
            for (char c : aI) {
                System.out.println(c);
                LockSupport.unpark(t2);
                LockSupport.park();
            }
        },"t1");


        t2=new Thread(()->{
            for (char c : aC) {
                LockSupport.park();
                System.out.println(c);
                LockSupport.unpark(t1);
            }
        },"t1");
        t1.start();
        t2.start();
    }
}

复制代码

结果

1
A
2
B
3
C
4
D
5
E
6
F
7
G
复制代码

方法二 用CAS自旋锁+volatitle来实现

复制代码

 enum  ReadyToRun {T1,T2}

  //先定义T1准备运行  而且要设置volatile 线程可见
  static volatile ReadyToRun r=ReadyToRun.T1;

    public static void main(String[] args) {

        char[] aI="1234567".toCharArray();
        char[] aC="ABCDEFG".toCharArray();


        new Thread(()->{
            for (char c : aI) {
                //如果不是T1准备运行 就一直返回空,直到T1运行打印,打印完之后把准备运行的变为T2
                while (r!=ReadyToRun.T1){}
                System.out.println(c);
                r=ReadyToRun.T2;
            }

        },"t1").start();


        new Thread(()->{
            for (char c : aC) {
                //如果不是T2准备运行 就一直返回空,直到T2运行打印,打印完之后把准备运行的变为T1
                while (r!=ReadyToRun.T2){}
                System.out.println(c);
                r=ReadyToRun.T1;
            }

        },"t1").start();

    }
复制代码

结果

1
A
2
B
3
C
4
D
5
E
6
F
7
G

复制代码

方法三 原子类 AtomicInteger

public class TestLockSupport {

    
    //定义一个原子性的对象
    static AtomicInteger thredNo=new AtomicInteger(1);

    public static void main(String[] args) {


        char[] aI="1234567".toCharArray();
        char[] aC="ABCDEFG".toCharArray();


        new Thread(()->{
            for (char c : aI) {
                //如果不是1就一直返回空,直到运行打印,打印完之后把原子对象变成2
                while (thredNo.get()!=1){}
                System.out.println(c);
                thredNo.set(2);
            }

        },"t1").start();


        new Thread(()->{
            for (char c : aC) {
                //如果不是2就一直返回空,直到运行打印,打印完之后把原子对象变成1
                while (thredNo.get()!=2){}
                System.out.println(c);
                thredNo.set(1);
            }

        },"t1").start();

    }
}

复制代码

方法四 也是面试官 想考你的 synchronized wait notiyfy

    public static void main(String[] args) {
    final  Object o=new Object();

        char[] aI="1234567".toCharArray();
        char[] aC="ABCDEFG".toCharArray();


        new Thread(()->{
            synchronized (o){
                for (char c : aI) {
                    try {
                        System.out.println(c);
                        o.wait();
                        o.notify();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                o.notify();
            }


        },"t1").start();


        new Thread(()->{
            synchronized (o){
                for (char c : aC) {
                    System.out.println(c);
                    o.notify();
                    try {
                        o.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                o.notify();
            }


        },"t1").start();

    }
复制代码

结尾

多线程的基础就讲到这里了,大家看完这些应该能够知道,线程的基本概况,接下来我们看看并发的锁吧

目录
相关文章
|
10天前
|
安全 Java 测试技术
Java并行流陷阱:为什么指定线程池可能是个坏主意
本文探讨了Java并行流的使用陷阱,尤其是指定线程池的问题。文章分析了并行流的设计思想,指出了指定线程池的弊端,并提供了使用CompletableFuture等替代方案。同时,介绍了Parallel Collector库在处理阻塞任务时的优势和特点。
|
7天前
|
安全 Java 开发者
深入解读JAVA多线程:wait()、notify()、notifyAll()的奥秘
在Java多线程编程中,`wait()`、`notify()`和`notifyAll()`方法是实现线程间通信和同步的关键机制。这些方法定义在`java.lang.Object`类中,每个Java对象都可以作为线程间通信的媒介。本文将详细解析这三个方法的使用方法和最佳实践,帮助开发者更高效地进行多线程编程。 示例代码展示了如何在同步方法中使用这些方法,确保线程安全和高效的通信。
27 9
|
10天前
|
存储 安全 Java
Java多线程编程的艺术:从基础到实践####
本文深入探讨了Java多线程编程的核心概念、应用场景及其实现方式,旨在帮助开发者理解并掌握多线程编程的基本技能。文章首先概述了多线程的重要性和常见挑战,随后详细介绍了Java中创建和管理线程的两种主要方式:继承Thread类与实现Runnable接口。通过实例代码,本文展示了如何正确启动、运行及同步线程,以及如何处理线程间的通信与协作问题。最后,文章总结了多线程编程的最佳实践,为读者在实际项目中应用多线程技术提供了宝贵的参考。 ####
|
7天前
|
监控 安全 Java
Java中的多线程编程:从入门到实践####
本文将深入浅出地探讨Java多线程编程的核心概念、应用场景及实践技巧。不同于传统的摘要形式,本文将以一个简短的代码示例作为开篇,直接展示多线程的魅力,随后再详细解析其背后的原理与实现方式,旨在帮助读者快速理解并掌握Java多线程编程的基本技能。 ```java // 简单的多线程示例:创建两个线程,分别打印不同的消息 public class SimpleMultithreading { public static void main(String[] args) { Thread thread1 = new Thread(() -> System.out.prin
|
10天前
|
Java
JAVA多线程通信:为何wait()与notify()如此重要?
在Java多线程编程中,`wait()` 和 `notify()/notifyAll()` 方法是实现线程间通信的核心机制。它们通过基于锁的方式,使线程在条件不满足时进入休眠状态,并在条件满足时被唤醒,从而确保数据一致性和同步。相比其他通信方式,如忙等待,这些方法更高效灵活。 示例代码展示了如何在生产者-消费者模型中使用这些方法实现线程间的协调和同步。
24 3
|
8天前
|
安全 Java
Java多线程集合类
本文介绍了Java中线程安全的问题及解决方案。通过示例代码展示了使用`CopyOnWriteArrayList`、`CopyOnWriteArraySet`和`ConcurrentHashMap`来解决多线程环境下集合操作的线程安全问题。这些类通过不同的机制确保了线程安全,提高了并发性能。
|
9天前
|
Java
java小知识—进程和线程
进程 进程是程序的一次执行过程,是系统运行的基本单位,因此进程是动态的。系统运行一个程序即是一个进程从创建,运行到消亡的过程。简单来说,一个进程就是一个执行中的程序,它在计算机中一个指令接着一个指令地执行着,同时,每个进程还占有某些系统资源如CPU时间,内存空间,文件,文件,输入输出设备的使用权等等。换句话说,当程序在执行时,将会被操作系统载入内存中。 线程 线程,与进程相似,但线程是一个比进程更小的执行单位。一个进程在其执行的过程中产生多个线程。与进程不同的是同类的多个线程共享同一块内存空间和一组系统资源,所以系统在产生一个线程,或是在各个线程之间做切换工作时,负担要比
21 1
|
10天前
|
Java UED
Java中的多线程编程基础与实践
【10月更文挑战第35天】在Java的世界中,多线程是提升应用性能和响应性的利器。本文将深入浅出地介绍如何在Java中创建和管理线程,以及如何利用同步机制确保数据一致性。我们将从简单的“Hello, World!”线程示例出发,逐步探索线程池的高效使用,并讨论常见的多线程问题。无论你是Java新手还是希望深化理解,这篇文章都将为你打开多线程的大门。
|
10天前
|
安全 Java 编译器
Java多线程编程的陷阱与最佳实践####
【10月更文挑战第29天】 本文深入探讨了Java多线程编程中的常见陷阱,如竞态条件、死锁、内存一致性错误等,并通过实例分析揭示了这些陷阱的成因。同时,文章也分享了一系列最佳实践,包括使用volatile关键字、原子类、线程安全集合以及并发框架(如java.util.concurrent包下的工具类),帮助开发者有效避免多线程编程中的问题,提升应用的稳定性和性能。 ####
38 1
|
Java Linux Windows
JAVA通信编程(五)——串口通讯的补充说明
在《JAVA通讯编程(一)——串口通讯》中讲述了如何采用JAVA进行串口通讯,我们采用的是引入RXTXComm.jar的方式,关于这个我有两点需要说明补充。 首先,现在的笔记本一般都不带串口,需要usb转串口之类的工具才能进行通讯,这样对调试程序非常的不方便,所以在windows操作系统下我们选择采用VSPD(Virtual Serial Port Driver)虚拟串口,VSPD对虚拟串口的序号没有限制,理论上可以创建无数个。
1720 0