201521123045 <java程序设计>第11周学习总结

201521123045 <java程序设计>第11周学习总结

1. 本周学习总结

2. 书面作业

2. 书面作业

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

import java.util.concurrent.locks.ReentrantLock;
import java.util.concurrent.locks.Condition;
 
class Account{
 
    private int balance;
    private Lock lock = new ReentrantLock();
        private Condition condition = lock.newCondition();
    public Account(int balance){
        this.balance=balance;
    }
 
    public int getBalance() {
        return balance;
    }
 
    public void setBalance(int balance) {
        this.balance = balance;
    }
 
      public  void deposit(int money){
         lock.lock();
         try{
             this.balance=getBalance() + money;
             condition.signal();//类似object的notify
         }
         finally
         {
             lock.unlock();
         }
     }
     public  void withdraw(int money){
         lock.lock();
         try{
             while (getBalance() <money) {
                 try {
                     condition.await();//类似object的wait
                 } catch (InterruptedException e) {
                     e.printStackTrace();
                 }
             }
             this.balance=getBalance() - money;
             condition.signal();//类似object的notify
         }
         finally{
             lock.unlock();
         }
     }
    }

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

同步方法直接在方法上加synchronized实现加锁，同步代码块则在方法内部加锁，很明显，同步方法锁的范围比较大，而同步代码块范围要小点，一般同步的范围越大，性能就越差，一般需要加锁进行同步的时候，肯定是范围
越小越好，这样性能更好

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

 
class Counter {
    private static int id = 0;
    public synchronized static void addId() {
        id++;
    }
    public synchronized static void subtractId() {
        id--;
    }
    public static int getId() {
        return id;
    }
}
同一时间内只能有一个线程访问对象，没有获得对象锁的线程在等待池中等待，等线程释放了对象锁，他们再开始竞争对象锁。

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

使用wait ()、notify()、notifyAll()实现线程之间的通信。
当两个并发线程访问同一个对象object中的这个synchronized(this)同步代码块时，一个时间内只能有一个线程得到执行。另一个线程必须等待当前线程执行完这个代码块以后才能执行该代码块。
synchronized可以避免多个线程访问同一资源引起错误。

Q2.交替执行
2.1 实验总结

这个实验关键问题在于让两个线程交替运行，用flag来判断用那个线程来访问资源，输出结果后用notify()唤醒另一个进程。要求我们熟练掌握交替运行。

Q3.互斥访问

3.1 修改TestUnSynchronizedThread.java源代码使其可以同步访问。(关键代码截图，需出现学号)

//
    public static synchronized void addId() {
            id++;
    }
    public static synchronized void subtractId() {
        id--;
    }
public static synchronized int GetId() {

       return id;
    }

3.2 进一步使用执行器改进相应代码(关键代码截图，需出现学号)

参考资料:Java多线程之Executor、ExecutorService、Executors、Callable、Future与FutureTask

4.线程间的合作：生产者消费者问题

4.1 运行MyProducerConsumerTest.java。正常运行结果应该是仓库还剩0个货物。多运行几次，观察结果，并回答：结果正常吗？哪里不正常？为什么？

不正常，有时会出现剩余货物还有10个，有可能出现生产者比消费者快，消费者来不及取数据，或者消费者消费的生产者生产的快，消费者取不到数据。

4.2 使用synchronized, wait, notify解决该问题(关键代码截图，需出现学号)

//
public synchronized void add（String t）{
 if （repo.size()>=capacity）
      try{
          system.out.println("仓库已满，无法添加货物");
          wait();
      }catch(Exception e) {
         system.out.println(e);
       }
       repo.add(t);
       notify();
}
}

Q5.查询资料回答：什么是线程安全？(用自己的话与代码总结，写自己看的懂的作业)

线程安全就是就是当一个程序对一个线程安全的方法或者语句进行访问的时候，其他的不能再对他进行操作了，必须等到这次访问结束以后才能对这个线程安全的方法进行访问.
存在竞争的线程不安全，不存在竞争的线程就是安全的。