第11周-多线程

最新推荐文章于 2024-10-16 10:13:45 发布

weixin_30408165

最新推荐文章于 2024-10-16 10:13:45 发布

阅读量90

点赞数

文章标签： java

原文链接：http://www.cnblogs.com/whting/p/6810028.html

版权

1. 本周学习总结

1.1 以你喜欢的方式（思维导图或其他）归纳总结多线程相关内容。

线程状态转换图

2. 书面作业

——本次PTA作业题集多线程

1. 互斥访问与同步访问

——完成题集4-4(互斥访问)与4-5(同步访问)

1.1 除了使用synchronized修饰方法实现互斥同步访问，还有什么办法实现互斥同步访问（请出现相关代码）？

答：除了synchronized方法外还有同步代码块、Lock。

相关代码1（同步代码块）：

public void deposit(int money) {
    synchronized(Account.class) {
        this.balance += money;
    }
}

相关代码2（Lock）：

private Lock poollock = new ReentrantLock();

public void withdraw(int money) {
    poollock.lock();
    setBalance(this.balance -= money);
    poollock.unlock();
}

1.2 同步代码块与同步方法有何区别？

答：首先语法不同；其次

同步代码块：
（1）加锁对象可以任意指定
（2）对方法内部加锁，加锁范围小，性能更好
（3）一个线程访问同步代码块时，另一个线程可以访问非同步代码块
同步方法：
（1）对当前对象加锁，相当于synchronized(this){}
（2）对方法加锁，加锁范围大，性能较差
（3）方法执行时，线程独占该锁

所声明为synchronized的成员函数中至多只有一个处于可执行的状态（因为至多只有一个能够获得该实例对应的锁），从而有效的避免了类成员变量的访问冲突。

1.3 实现互斥访问的原理是什么？请使用对象锁概念并结合相应的代码块进行说明。当程序执行synchronized同步代码块或者同步方法时，线程的状态是怎么变化的？

答：
（1）

实现互斥访问的原理：
一个线程调用加上同步的方法时，取得对象锁定；另一个线程想调用同一方法时必须等待前一个线程执行完毕释放锁定后取得锁定才能进入可执行状态。
以下代码获得this这个对象上的内部锁；如果未获得对象锁，下面的代码就无法执行，必须等待；从而通过对象锁实现了互斥访问。

class MyCounter{
   private int i = 0;
   public void increment(){
      //i++;
      synchronized (this) {
      i++;
      }
   }
    ………
}

（2）

相应程序的例子

public class SynchronizedStatementTest {

    public static void main(String[] args) throws InterruptedException {
        final MyCounter counter = new MyCounter();
        
        
        Runnable incTask = new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < 10000; i++) {
                    counter.increment();
                }
            }
        };
        Runnable decTask = new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < 10000; i++) {
                    counter.decrement();
                }
            }
        };
        Thread t1 = new Thread(incTask);
        Thread t2 = new Thread(decTask);
        t1.start();t2.start();
        t1.join();
        t2.join();
        System.out.println("counter's value is "+counter.getValue());
        System.out.println("End!");
    }
}
class MyCounter{
    private int i = 0;
    public void increment(){
        //i++;
        synchronized (this) {
            i++;
        }
    }
    public void decrement(){
        //i--;
        synchronized (this) {
            i--;
        }
    }
    public int getValue(){
        return i;
    }
}

线程的状态变化情况：
（1）线程t1开始执行时，将i加锁，取得i的值为0；
（2）然后执行i++，此时i内存的值1，释放当前i上的锁；
（3）这时线程t2可以开始执行并使i加锁，取得i的值为1；
（4）执行i--，将计算后的值存到i，此时i为0，释放当前i上的锁。
如果线程未获得对象锁，必须等待前一线程完成执行过程，释放当前对象的锁。

1.4 Java多线程中使用什么关键字实现线程之间的通信，进而实现线程的协同工作？为什么同步访问一般都要放到synchronized方法或者代码块中？

答：

线程的协同工作的关键字：
（1）wait()和notify()/notifyAll()——只能在被声明为synchronized的方法或代码段中调用
（2）Condition（使用条件对象）——需要搭配Lock对象来使用
同步访问一般都要放到synchronized方法或者代码块中的原因：
synchronized方法或者代码块相当于对象监视器。
因为存储容量是有限的，当一个线程占满容量时，该线程需要被wait，等到满满的资源被消费掉一些时，该线程需要被notify继续工作；当容量被某线程消费完毕了，此线程需要被wait，等存储中有资源了，此线程将才被notify继续工作。