黑马程序员——多线程第二天

------Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ -------

多线程

一、多线程缺点：

如果有大量的线程,会影响性能,因为操作系统需要在它们之间切换。

更多的线程需要更多的内存空间。

线程可能会给程序带来更多“bug”，因此要小心使用。

线程的中止需要考虑其对程序运行的影响。

通常块模型数据是在多个线程间共享的，需要防止线程死锁情况的发生。

二、线程安全问题

1、导致安全问题的出现的原因：

        当多条语句在操作同一线程共享数据时，一个线程对多条语句只执行了一部分，还没用执行完，另一个线程参与进来执行。导致共享数据的错误。

简单的说就两点：

        a、多个线程访问出现延迟。

        b、线程随机性    。

注：线程安全问题在理想状态下，不容易出现，但一旦出现对软件的影响是非常大的。

2、解决办法——同步

        对多条操作共享数据的语句，只能让一个线程都执行完。在执行过程中，其他线程不可以参与执行。

        在java中对于多线程的安全问题提供了专业的解决方式——synchronized（同步）

        这里也有两种解决方式，一种是同步代码块，还有就是同步函数。都是利用关键字synchronized来实现。

         a、同步代码块

        用法：

                  synchronized（对象）

                  {需要被同步的代码}

        同步可以解决安全问题的根本原因就在那个对象上。其中对象如同锁。持有锁的线程可以在同步中执行。没有持有锁的线程即使获取cpu的执行权，也进不去，因为没有获取锁。

示例：

class Ticket implements Runnable{private int tick=100;Object obj = new Object();public void run(){while(true){//给程序加同步，即锁synchronized(obj){if(tick>0){try{//使用线程中的sleep方法，模拟线程出现的安全问题//因为sleep方法有异常声明，所以这里要对其进行处理Thread.sleep(10);}catch (Exception e){}//显示线程名及余票数System.out.println(Thread.currentThread().getName()+"..tick="+tick--);}}}}}

b，同步函数

        格式：

                在函数上加上synchronized修饰符即可。

        那么同步函数用的是哪一个锁呢？

        函数需要被对象调用。那么函数都有一个所属对象引用。就是this。所以同步函数使用的锁是this。

拿同步代码块的示例：

class Ticket implements Runnable{private int tick=100;Object obj = new Object();public void run(){while(true){show();}} //直接在函数上用synchronized修饰即可实现同步public synchronized void show(){if(tick>0) {try{//使用线程中的sleep方法，模拟线程出现的安全问题//因为sleep方法有异常声明，所以这里要对其进行处理Thread.sleep(10);}catch (Exception e){}//显示线程名及余票数System.out.println(Thread.currentThread().getName()+"..tick="+tick--);}}}

3、同步的前提

        a，必须要有两个或者两个以上的线程。

        b，必须是多个线程使用同一个锁。

4、同步的利弊

        好处：解决了多线程的安全问题。

        弊端：多个线程需要判断锁，较为消耗资源。

5、如何寻找多线程中的安全问题

        a，明确哪些代码是多线程运行代码。

        b，明确共享数据。

        c，明确多线程运行代码中哪些语句是操作共享数据的。

三、静态函数的同步方式

        如果同步函数被静态修饰后，使用的锁是什么呢？

        通过验证，发现不在是this。因为静态方法中也不可以定义this。静态进内存时，内存中没有本类对象，但是一定有该类对应的字节码文件对象。如：

        类名.class 该对象的类型是Class

这就是静态函数所使用的锁。而静态的同步方法，使用的锁是该方法所在类的字节码文件对象。类名.class

示例：

/*加同步的单例设计模式————懒汉式*/class Single{private static Single s = null;private Single(){}public static void getInstance(){if(s==null){synchronized(Single.class){if(s==null)s = new Single();}}return s;}}

四、死锁

        当同步中嵌套同步时，就有可能出现死锁现象。

示例：

//定义一个类来实现Runnable，并复写run方法class LockTest implements Runnable{private boolean flag;LockTest(boolean flag){this.flag=flag;}public void run(){if(flag){while(true){synchronized(LockClass.locka)//a锁{System.out.println(Thread.currentThread().getName()+"------if_locka");synchronized(LockClass.lockb)//b锁{System.out.println(Thread.currentThread().getName()+"------if_lockb");}}}}else{while(true){synchronized(LockClass.lockb)//b锁{ System.out.println(Thread.currentThread().getName()+"------else_lockb");synchronized(LockClass.locka)//a锁{ System.out.println(Thread.currentThread().getName()+"------else_locka");}}}}}}//定义两个锁class LockClass{static Object locka = new Object();static Object lockb = new Object();}class DeadLock{public static void main(String[] args){//创建2个进程，并启动new Thread(new LockTest(true)).start();new Thread(new LockTest(false)).start();}}

结果：程序卡住，不能继续执行

五、线程间通信

        其实就是多个线程在操作同一个资源，但是操作的动作不同。

1、使用同步操作同一资源的示例：

import java.util.concurrent.locks.*;class Resourse{private String name;private int count=1;private boolean flag=false;private ReentrantLock lock=new ReentrantLock();private Condition con_Pro=lock.newCondition();private Condition con_Con=lock.newCondition();public void set(String name) throws InterruptedException{lock.lock();try{while(flag)con_Pro.await();this.name=name+"--"+count++;System.out.println(Thread.currentThread()+"----------生产者"+this.name);flag=true;con_Con.signal();}finally{lock.unlock();}}public void get() throws InterruptedException{lock.lock();try{while(!flag)con_Con.await();System.out.println(Thread.currentThread()+"消费者"+name);flag=false;con_Pro.signal();}finally{lock.unlock();}}}class Producer implements Runnable{private Resourse res;Producer(Resourse res){this.res=res;}public void run(){while(true){try{res.set("商品");}catch(InterruptedException e){}}}}class Consumer implements Runnable{private Resourse res;Consumer(Resourse res){this.res=res;}public void run(){while(true){try{res.get();}catch(InterruptedException e){}}}}public class Lock {public static void main(String[] args){Resourse res=new Resourse();Producer p=new Producer(res);Consumer c=new Consumer(res);Thread th1=new Thread(p);Thread th2=new Thread(p);Thread th3=new Thread(c);Thread th4=new Thread(c);Thread th5=new Thread(c);th1.start();th2.start();th3.start();th4.start();th5.start();}}

结果：部分截图