第Ⅱ期Android菜鸟饭团#Java学习#第十九课 活动笔记

xiao_ming

第Ⅱ期Android菜鸟饭团#Java学习#第十九课 活动笔记

一、线程同步：

# 分析

上图光标处需加一行代码

tt.m2();        

        输出结果：1000

                        b = 1000

造成这种现象的原因是另一个线程调用一个没有锁定的方法时是可以访问已锁定的对象如果是调用锁定的方法就能访问该对象

#同步机制

        在多线程中，可能有多个线程试图访问一个有限的资源，必须预防这种情况的发生。所以引入了同步机制：在线程使用一个资源时为其加锁，这样其他的线程便不能访问那个资源了，直到解锁后才可以访问。

#共享成员变量的例子

        成员变量：

        如果一个变量是成员变量，那么多个线程对同一个对象的成员变量进行操作，这多个线程是共享一个成员变量的。

        局部变量：

        如果一个变量是局部变量，那么多个线程对同一个对象进行操作，每个线程都会有一个该局部变量的拷贝。他们之间的局部变量互不影响。

#举例

        实现了Runnable的线程类：

class MyThread3 implements Runnable{ //两个线程操作同一个对象，共享成员变量     //int i;     @Override     public void run() {         //两个线程操作同一个对象，各自保存局部变量的拷贝         int i = 0;         while(i<100){             System.out.println(i);             i++;             try {                 Thread.sleep(100);             } catch (InterruptedException e) {                 e.printStackTrace();             }         }     } }

        在main方法中用两个线程操作同一个对象：

public static void main(String[] args) {     MyThread3 myThread = new MyThread3();     //下面两个线程对同一个对象(Runnable的实现类对象)进行操作     Thread thread = new Thread(myThread);     Thread thread2 = new Thread(myThread);     //各自保存局部变量的拷贝，互不影响，输出200个数字     thread.start();     thread2.start(); }

        这里如果把i变成成员变量，则输出100个数字。

#共享资源导致的读取错误

        下面举个例子，两个线程共用一个Number对象，通过Number类的getNumber方法获取数据，读取数据并改写时，发现了重复读操作：

首先创建一个Number类：

class Number{     private int number = 10;     public String getNumber(int i){         if(number > 0){             try {                 Thread.sleep(100);             } catch (InterruptedException e) {                 e.printStackTrace();             }             number -= i;             return "取出"+i+"成功，剩余数量："+number;         }         return "取出"+i+"失败，剩余数量："+number;     } }

        线程类，在线程类中的私有属性包含了Number类的引用：

class MyThread4 extends Thread{     //两个线程操作同一个对象，共享成员变量     Number number;     public MyThread4(Number number){         this.number = number;     }     @Override     public void run() {         System.out.println(number.getNumber(8));     } }

        在main函数中创建两个线程类，包含了同一个Number类实例的引用：

public static void main(String[] args) {     Number number = new Number();     //两个线程操作同一个对象，共享对象number的成员变量number     MyThread4 myThread = new MyThread4(number);     MyThread4 myThread2 = new MyThread4(number);     myThread.start();     myThread2.start(); }

        这样，当第一个线程读取Number中的number变量时先保存下来再休眠0.1秒，然后第二个线程再读取number变量并保存，此时两个线程保存了同样的数字，在修改时，也就导致修改了同一个数字两次。

同步机制的实现

#使用synchronized关键字创建synchronized方法

        1.使用synchronized关键字，该关键字修饰的方法叫做同步方法；

        2.Java中每个对象都有一个锁或者称为监视器，当访问某个对象的synchronized方法时，表示将该对象上锁，而不仅仅是为该方法上锁；

        3.这样如果一个对象的synchronized方法被某个线程执行时，其他线程无法访问该对象的任何synchronized方法（但是可以调用其他非synchronized的方法）。直至该synchronized方法执行完；

#静态的synchronized方法调用情况

        1.当调用一个对象的静态synchronized方法时，它锁定的并不是synchronized方法所在的对象，而是synchronized方法所在对象对应的Class对象。这样，其他线程就不能调用该类的其他静态synchronized方法了，但是可以调用非静态的synchronized方法。

        2.结论：执行静态synchronized方法锁方法所在对象，执行非静态synchronized方法锁方法所在对象对应的Class对象；

#下面是多线程调用静态的方法的例子，由于锁定了方法所在对象对应的Class对象，其他线程无法调用该方法所在对象其他的静态synchronized方法：

/** * 定义一个类，包含了线程类需要调用的方法 */ class Compute1{     //这时如果某个线程调用该方法，     //将锁定synchronized方法所在对象对应的class对象，     //而不是锁定synchronized方法所在对象     public synchronized static void execute(){         for(int i = 0; i<100; i++){             try {                 Thread.sleep(100);             } catch (InterruptedException e) {                 e.printStackTrace();             }             System.out.println("compute1:execute1 " + i++);         }     }     public synchronized static void execute2(){         for(int i = 0; i<100; i++){             try {                 Thread.sleep(100);             } catch (InterruptedException e) {                 e.printStackTrace();             }             System.out.println("compute1:execute2 " + i++);         }     } }

        main方法中两个线程分别调用同一个对象的两个static synchronized方法：

public static void main(String[] args) {     Compute1 com = new Compute1();     Thread thread1 = new Thread1(com);     Thread thread2 = new Thread2(com);     thread1.start();     thread2.start(); }

#使用synchronized创建同步代码块

        通过使用synchronized同步代码块，锁定一个对象，该对象作为可执行的标志从而达到同步的效果：

/** * 定义一个类，包含了线程类需要调用的方法 */ class Compute1{     //通过同步代码块锁定object1对象进行锁定了其他同样的synchronized代码块     private Object object1 = new Object();     public void execute(){         synchronized(object1){             for(int i = 0; i<100; i++){                 try {                     Thread.sleep(100);                 } catch (InterruptedException e) {                     e.printStackTrace();                 }                 System.out.println("compute1:execute1 " + i++);             }         }     }     public synchronized void execute2(){         synchronized(object1){             for(int i = 0; i<100; i++){                 try {                     Thread.sleep(100);                 } catch (InterruptedException e) {                     e.printStackTrace();                 }                 System.out.println("compute1:execute2 " + i++);             }         }     } }

小结.

1、线程同步的目的是为了保护多个线程访问一个资源时对资源的破坏。

2、线程同步方法是通过锁来实现，每个对象都有且仅有一个锁，这个锁与一个特定的对象关联，线程一旦获取了对象锁，其他访问该对象的线程就无法再访问该对象的其他同步方法。

3、对于静态同步方法，锁是针对这个类的，锁对象是该类的Class对象。静态和非静态方法的锁互不干预。一个线程获得锁，当在一个同步方法中访问另外对象上的同步方法时，会获取这两个对象锁。

4、对于同步，要时刻清醒在哪个对象上同步，这是关键。

5、编写线程安全的类，需要时刻注意对多个线程竞争访问资源的逻辑和安全做出正确的判断，对“原子”操作做出分析，并保证原子操作期间别的线程无法访问竞争资源。

6、当多个线程等待一个对象锁时，没有获取到锁的线程将发生阻塞。

每一个技术小白都有一个成为大神的梦想，现在Android菜鸟饭团就给你这个成就梦想的机会。我们提供最新的Android技术教学，只要你又耐心和毅力就一定会在这里有所收获。

Android菜鸟饭团由南阳GDG组织发起，秉承着开放、分享、创新的原则，希望通过GDG社区的力量能够给更多的想要学习Android开发技术的小白们创造一个学习，交流，分享的环境。同往常的GDG活动一样，我们依然是任性的一个子都不要，并且还在周六的分享中提供盒饭和不定期的惊喜小礼物呦~所以快来加入我们吧，为你的大神梦想迈出第一步。

把你的个人信息和申请理由快快发送到android@chuang1.net，前来加入我们吧