并发编程第二篇，线程之间的通讯

 

• 并发与并行的区别

所有的并发处理都有排队等候，唤醒，执行至少三个这样的步骤.所以并发肯定是宏观概念，在微观上他们都是序列被处理的，只不过资源不会在某一个上被阻塞(一般是通过时间片轮转)，所以在宏观上看多个几乎同时到达的请求同时在被处理。如果是同一时刻到达的请求也会根据优先级的不同，而先后进入队列排队等候执行。

    并发并行是两个既相似而又不相同的概念：并发性，又称共行性，是指能处理多个同时性活动的能力；并行是指同时发生的两个并发事件，具有并发的含义，而并发则不一定并行，也亦是说并发事件之间不一定要同一时刻发生。

并发的实质是一个物理CPU(也可以多个物理CPU) 在若干道程序之间多路复用，并发性是对有限物理资源强制行使多用户共享以提高效率。

并行性指两个或两个以上事件或活动在同一时刻发生。在多道程序环境下，并行性使多个程序同一时刻可在不同CPU上同时执行

打个比方。并发，就像一个人（cpu）喂2个孩子（程序），轮换着每人喂一口，表面上两个孩子都在吃饭。并行，就是2个人喂2个孩子，两个孩子也同时在吃饭。

并发拥有同时处理某个活动的能力，在没加锁的时候，多个线程执行一段代码方法或者共享变量的情况下可能会出现两个线程同时执行该方法或者获取变量的情况所以会产生线程安全问题。比如单例的懒汉创建模式。并行和并发不同垃圾回收器也有不同应用

• 多线程之间如何同步

什么是线程安全

当多个线程同时共享同一个全局变量做写的操作时候，可能会受到其他线程的干扰。

如何解决线程安全问题

 

public class TicketThread implements Runnable {     private  int count = 100;     @Override     public void run() {         while (count > 0) {             try {                 Thread.sleep(30);             } catch (Exception e) {             }             ticket();         }     }     private void ticket() {         if (count > 0) {             System.out.println(Thread.currentThread().getName() + ",正在开始出售:" + (100 - count + 1));             count--;         }     }     public static void main(String[] args) {         TicketThread ticketThread = new TicketThread();         Thread thread1 = new Thread(ticketThread, "窗口1");         Thread thread2 = new Thread(ticketThread, "窗口2");         thread1.start();         thread2.start();     } }

 

 

 

解决办法：

1. 使用java锁的机制 Synchronized、或者Lock锁 还有CAS无锁机制。
2.  

对于代码中如果在多线程同时执行操作的情况下，可能会受到其他线程的干扰的代码采用锁的机制，在同一个时刻只能保证只有一个线程去执行。也就是只要获取到锁的之后，才能够进入该代码块执行，代码执行完之后释放锁之后其他线程才可以执行。

3.没有获取到锁的线程，则一直会排队阻塞，整个过程是一个悲观状态。

Synchronized的基本用法

修饰代码块

private static String lock = "lock"; private static void ticket() {     synchronized (TicketThread.class) {         if (count > 0) {             System.out.println(Thread.currentThread().getName() + ",正在开始出售:" + (100 - count + 1));             count--;         }     } } public static void main(String[] args) {     TicketThread ticketThread = new TicketThread();     Thread thread1 = new Thread(ticketThread, "窗口1");     Thread thread2 = new Thread(ticketThread, "窗口2");     thread1.start();     thread2.start(); }

 

public class TicketThread implements Runnable {     private static int count = 100;     @Override     public void run() {         while (count > 0) {             try {                 Thread.sleep(30);             } catch (Exception e) {             }             ticket();         }     }     private static String lock = "lock";     private void ticket() {         synchronized (this) {             if (count > 0) {                 System.out.println(Thread.currentThread().getName() + ",正在开始出售:" + (100 - count + 1));                 count--;             }         }     }     public static void main(String[] args) {         TicketThread ticketThread = new TicketThread();         Thread thread1 = new Thread(ticketThread, "窗口1");         Thread thread2 = new Thread(ticketThread, "窗口2");         thread1.start();         thread2.start();     } }

 

可以定义任意对象作为锁，但是需要注意：如果该方法为普通方法的情况下 可以使用普通对象或者属性作为锁。

如果该方法为静态方法的情况，则必须使用当前类的Class或者是静态属性作为锁。

 

实例方法

如果在普通方法上加上锁，则表示使用this锁

静态代码块

如果是在静态方法上加上锁，则表示使用当前类的.class锁。

为什么使用锁之后，能够保证线程安全

核心思路：在同一时刻，能够有多个线程操作共享变量。

因为使用锁了之后，多个线程在同时执行该代码的时候，必须要获取到锁，只有获取到锁的情况下，才可以进入到该方法。

比如A线程获取到了之后，B线程则一直阻塞等待，必须等待A线程执行完毕释放了锁之后，B才可以重新进入到获取锁的过程。

 

简单回顾双重检验锁原理

public class Singleton03 {     private static Singleton03 singleton03;     private Singleton03() {     }     public static Singleton03 getInstance() {         // 上锁（创建该对象） 第一次判断         if (singleton03 == null) {             synchronized (Singleton03.class) {                 //第二次判断                 if (singleton03 == null) {                     singleton03 = new Singleton03();                 }             }         }         return singleton03;     }     public static void main(String[] args) {         Singleton03 instance1= Singleton03.getInstance();         Singleton03 instance2= Singleton03.getInstance();         System.out.println(instance1==instance2);     } }

 

简单理解锁的可重入性

当一个线程获取到锁之后，在此请求获取该锁的时候，直接可以获取该对象锁。

public class Thread006 implements Runnable {     @Override     public void run() {         System.out.println(Thread.currentThread().getName() + ",我是子线程");         a();     }     public synchronized void a() {         System.out.println(Thread.currentThread().getName() + ",我是方法A");         b();     }     public synchronized void b() {         System.out.println(Thread.currentThread().getName() + ",我是方法B");     } }

多线程死锁产生的原因

在同步中嵌套同步，会出现死锁的现象

import java.util.Objects; import java.util.concurrent.Callable; public class Thread004 implements Runnable {     private static int count = 100;     private Boolean flag = true;     private Object object = new Object();     @Override     public void run() {         if (flag) {             while (count > 0) {                 synchronized (object) {                     try {                         Thread.sleep(10);                     } catch (Exception e) {                     }                     ticket();                 }             }         } else {             while (count > 0) {                 ticket();             }         }     }     private synchronized void ticket() {         synchronized (object) {             try {                 Thread.sleep(10);             } catch (Exception e) {             }             if (count > 0) {                 System.out.println(Thread.currentThread().getName() + ",正在开始出售:" + (100 - count + 1));                 count--;             }         }     }     public static void main(String[] args) {         Thread004 thread004 = new Thread004();         new Thread(thread004, "窗口1").start();         try {             Thread.sleep(40);             thread004.flag = false;         } catch (Exception e) {         }         new Thread(thread004, "窗口2").start();     } }   程序中死锁诊断工具   查找到当前JVM环境变量E:\java8\jdk  找到 jconsole.exe工具，   Lock锁的基本用法 重入锁（ReentrantLock） import java.util.concurrent.locks.Lock; import java.util.concurrent.locks.ReentrantLock; public class Thread005 implements Runnable {     private static int count = 100;     private Lock lock = new ReentrantLock();     @Override     public void run() {         while (count > 0) {             ticket();         }     }     private void ticket() {         try {             Thread.sleep(30);         } catch (Exception e) {         }         try {             lock.lock(); //           try { //           } catch (Exception e) { // //           }             if (count > 0) {                 System.out.println(Thread.currentThread().getName() + ",正在开始出售:" + (100 - count + 1));                 count--;             }         } catch (Exception e) {         } finally {             lock.unlock();         }     }     public static void main(String[] args) {         Thread005 thread005 = new Thread005();         new Thread(thread005, "窗口1").start();         new Thread(thread005, "窗口2").start();     } }     读写锁（ReadAndWriteLock） 读读共享、写写互斥、读写互斥。 import java.util.concurrent.locks.ReentrantReadWriteLock; public class MyTask {     ReentrantReadWriteLock lock = new ReentrantReadWriteLock();     /**      * 读读共享      */     public void read() {         lock.readLock().lock();         try {             System.out.println(Thread.currentThread().getName() + ",正在开始读取");             Thread.sleep(1000);             System.out.println(Thread.currentThread().getName() + ",正在结束读取");         } catch (Exception e) {         }         lock.readLock().unlock();     }     /**      * 写写互斥      */     public void write() {         lock.writeLock().lock();         try {             System.out.println(Thread.currentThread().getName() + ",正在开始写入");             Thread.sleep(1000);             System.out.println(Thread.currentThread().getName() + ",正在结束写入");         } catch (Exception e) {         }         lock.writeLock().unlock();     }     public static void main(String[] args) {         MyTask myTask = new MyTask(); //        for (int i = 0; i < 10; i++) { //            new Thread(() -> { //                myTask.write(); //            }).start(); //        }       for (int i =0; i <10;i++){           new Thread(() -> {               myTask.read();           }).start();           new Thread(() -> {               myTask.write();           }).start();       }     } }       Lock与Synchronized锁的区别   Synchronized属于java内置的关键字，而lock锁是基于aqs封装的一个锁的框架 Synchronized当代码执行结束自动释放锁，而lock需要人工释放锁，相对于来说lock锁更加灵活。 第三章-多线程之间如何实现通讯  多线程之间如何实现通讯     多个线程对同一个对象实现，实现做不同的操作，过程可以称作为多线之间实现通讯。   public class Thread007 {     class Res {         public String userName;         public char userSex;         public boolean flag;     }     class InputThread extends Thread {         private Res res;         public InputThread(Res res) {             this.res = res;         }         @Override         public void run() {             try {                 int count = 0;                 while (true) {                     synchronized (res) {                         if (this.res.flag) {                             res.wait();                         }                         if (count == 0) {                             this.res.userName = "小A";                             this.res.userSex = '女';                         } else {                             this.res.userName = "小B";                             this.res.userSex = '男';                         }                         this.res.flag = true;                         this.res.notify();                     }                     count = (count + 1) % 2;                 }             } catch (Exception e) {             }         }     }     class OutThread extends Thread {         private Res res;         public OutThread(Res res) {             this.res = res;         }         @Override         public void run() {             while (true) {                 try {                     synchronized (res) {                         if (!res.flag) {                             res.wait();                         }                         System.out.println(res.userName + "," + res.userSex);                         res.flag = false;                         res.notify();                     }                 } catch (Exception e) {                 }             }         }     }     public static void main(String[] args) {         new Thread007().start();     }     private void start() {         Res res = new Res();         InputThread inputThread = new InputThread(res);         OutThread outThread = new OutThread(res);         inputThread.start();         outThread.start();     } }      Wait、Notify（）用法 因为涉及到对象锁， wait、Notify 必须要在synchronized中使用 Wait会暂停当前线程，释放cpu执行资格，同时释放锁。 Notify 唤醒锁池正在等待的线 面试题：手写一个两个线程交替打印1到10 public class Thread1 implements Runnable { // private Object o =new Object(); int num = 1; @Override public void run() { while (true){ synchronized (this){ notify(); if (num <11 ){ System.out.println(Thread.currentThread().getName()+"当前数字为="+num); num++; }else { break; } try { wait(); } catch (InterruptedException e) { e.printStackTrace(); } } } } } public class ThreadTest { public static void main(String[] args) throws InterruptedException { Thread1 th = new Thread1(); Thread t1 = new Thread(th); Thread t2 = new Thread(th); t1.setName("线程A"); t2.setName("线程B"); t1.start(); t2.start(); } }     如果把 this改成object o的话运行会抛异常，同时获取object o的锁产生死锁，我等待你，你等待我 Exception in thread "线程A" Exception in thread "线程B" java.lang.IllegalMonitorStateException 虽然主线程是顺序执行的，但是执行的足够快的时候也有可能产生线程B先打印1的情况，如果一定要线程A先打印呢？代码如何优化，可以在t1.start之后让主线程停顿几毫秒 实现这个方法还有很多比如：LockSupport.park(); LockSupport.unpark(t1); 方法     join方法， thread.Join把指定的线程加入到当前线程，可以将两个交替执行的线程合并为顺序执行的线程。比如在线程B中调用了线程A的Join()方法，直到线程A执行完毕后，才会继续执行线程B。 t.join();      //使调用线程 t 在此之前执行完毕。 t.join(1000);  //等待 t 线程，等待时间是1000毫秒 Join方法实现是通过wait（小提示：Object 提供的方法）。 当main线程调用t.join时候，main线程会获得线程对象t的锁（wait 意味着拿到该对象的锁),调用该对象的wait(等待时间)，直到该对象唤醒main线程 ，比如退出后。这就意味着main 线程调用t.join时，必须能够拿到线程t对象的锁   每一行代码都有它的涵义，多问一句为什么；别怕，理清思路，一切代码都是数据的流动和转化，耐心一点，慢慢积累！一起加油！！！