201871010117-石欣钰《面向对象程序设计(JAVA)》第十七周学习总结

项目

内容

《面向对象程序设计(java)》

https://home.cnblogs.com/u/nwnu-daizh/

这个作业的要求在哪里

https://www.cnblogs.com/nwnu-daizh/p/12073034.html

作业学习目标

(1) 理解和掌握线程的优先级属性及调度方法;

(2) 掌握线程同步的概念及实现技术;

(3) Java线程综合编程练习

 

第一部分:理论知识

1.多线程的概念:

(1)多线程是进程执行过程中产生的多条执行线索。 

(2)多线程意味着一个程序的多行语句可以看上去几 乎在同一时间内同时运行。 

(3)线程不能独立存在,必须存在于进程中,同一进 程的各线程间共享进程空间的数据。 

Java实现多线程有两种途径:
创建Thread类的子类
在程序中定义实现Runnable接口的类

用Thread类的子类创建线程:

(1)首先需从Thread类派生出一个子类,在该子类中 重写run()方法。 

例: class hand extends Thread {

public void run() {……}

}

(2) 然后用创建该子类的对象 

Lefthand left=new Lefthand();

Righthand right=new Righthand(); 

(3)最后用start()方法启动线程 

left.start();

right.start();

用Thread类的子类创建多线程的关键性操作:

(1)定义Thread类的子类并实现用户线程操作,即 run()方法的实现。

(2)在适当的时候启动线程。

由于Java只支持单重继承,用这种方法定义的类不 可再继承其他父类。

用Runnable()接口实现线程

(1)首先设计一个实现Runnable接口的类; 

(2) 然后在类中根据需要重写run方法; 

(3)再创建该类对象,以此对象为参数建立Thread 类的对象; 

(4)调用Thread类对象的start方法启动线程,将 CPU执行权转交到run方法。

被阻塞线程和等待线程

 blocked (被阻塞):

阻塞时线程不能进入队列排队,必须等到引起 阻塞的原因消除,才可重新进入排队队列。 

sleep(),wait()是两个常用引起线程阻塞的方法。

线程阻塞的三种情况:

(1)等待阻塞 :通过调用线程的wait()方法,让线 程等待某工作的完成。 

(2)同步阻塞 :线程在获取synchronized同步锁失 败(因为锁被其它线程所占用),它会进入同步阻 塞状态。 

(3)其他阻塞 :通过调用线程的sleep()或join() 或发出了I/O请求时,线程会进入到阻塞状态。当 sleep()状态超时、join()等待线程终止或者超 时、或者I/O处理完毕时,线程重新转入就绪状态。

被终止的线程

 Terminated (被终止) 线程被终止的原因有二: 

(1)一是run()方法中最后一个语句执行完毕而自 然死亡。 

(2)二是因为一个没有捕获的异常终止了run方法 而意外死亡。 

可以调用线程的stop 方 法 杀 死 一 个 线 程 (thread.stop();),但是,stop方法已过时, 不要在自己的代码中调用它。

其他判断和影响线程状态的方法:

(1)join():等待指定线程的终止。 

(2)join(long millis):经过指定时间等待终止指定 的线程。 

(3)isAlive():测试当前线程是否在活动。 

(4)yield():让当前线程由“运行状态”进入到“就 绪状态”,从而让其它具有相同优先级的等待线程 获取执行权。

多线程调度

(1)Java提供一个线程调度器来监控程序启动后进入可运行状态的所有线程。线程调度器按照线程的优先级决定应调度哪些线程来执行。

(2)处于可运行状态的线程首先进入就绪队列排队等候处理器资源,同一时刻在就绪队列中的线程可能有多个。Java的多线程系统会给每个线程自动分配一个线程的优先级。

 Java 的线程调度采用优先级策略:

(1)优先级高的先执行,优先级低的后执行;

(2)多线程系统会自动为每个线程分配一个优先级,缺省时,继承其父类的优先级;

(3)任务紧急的线程,其优先级较高;

(4)同优先级的线程按“先进先出”的队列原则;

守护线程

守护线程的惟一用途是为其他线程提供服务。例 如计时线程。

在一个线程启动之前,调用setDaemon方法可 将线程转换为守护线程(daemon thread)。 例如: setDaemon(true);

第二部分:

实验一:

测试程序1:

测试代码:

package synch;

import java.util.*;
import java.util.concurrent.locks.*;

/**
 * A bank with a number of bank accounts that uses locks for serializing access.
 * @version 1.30 2004-08-01
 * @author Cay Horstmann
 */
public class Bank
{
   private final double[] accounts;
   private Lock bankLock;
   private Condition sufficientFunds;

   /**
    * Constructs the bank.
    * @param n the number of accounts
    * @param initialBalance the initial balance for each account
    */
   public Bank(int n, double initialBalance)
   {
      accounts = new double[n];
      Arrays.fill(accounts, initialBalance);
      bankLock = new ReentrantLock();
      sufficientFunds = bankLock.newCondition();
   }

   /**
    * Transfers money from one account to another.
    * @param from the account to transfer from
    * @param to the account to transfer to
    * @param amount the amount to transfer
    */
   public void transfer(int from, int to, double amount) throws InterruptedException//当线程在活动之前或活动期间处于正在等待、休眠或占用状态且该线程被中断时,抛出该异常。
   {
      bankLock.lock();//加锁
      try
      {
         while (accounts[from] < amount)//条件对象判断当前对象是否进入
            sufficientFunds.await();//造成当前线程在接到信号或被中断之前一直处于等待状态。
         System.out.print(Thread.currentThread());
         accounts[from] -= amount;
         System.out.printf(" %10.2f from %d to %d", amount, from, to);
         accounts[to] += amount;
         System.out.printf(" Total Balance: %10.2f%n", getTotalBalance());
         sufficientFunds.signalAll();
      }
      finally
      {
         bankLock.unlock();//释放锁
      }
   }

   /**
    * Gets the sum of all account balances.
    * @return the total balance
    */
   public double getTotalBalance()
   {
      bankLock.lock();
      try
      {
         double sum = 0;

         for (double a : accounts)
            sum += a;

         return sum;
      }
      finally
      {
         bankLock.unlock();
      }
   }

   /**
    * Gets the number of accounts in the bank.
    * @return the number of accounts
    */
   public int size()
   {
      return accounts.length;
   }
}
package synch;

/**
 * This program shows how multiple threads can safely access a data structure.
 * @version 1.31 2015-06-21
 * @author Cay Horstmann
 */
public class SynchBankTest
{
   public static final int NACCOUNTS = 100;
   public static final double INITIAL_BALANCE = 1000;
   public static final double MAX_AMOUNT = 1000;
   public static final int DELAY = 10;
   
   public static void main(String[] args)
   {
      Bank bank = new Bank(NACCOUNTS, INITIAL_BALANCE);
      for (int i = 0; i < NACCOUNTS; i++)
      {
         int fromAccount = i;
         Runnable r = () -> {
            try
            {
               while (true)
               {
                  int toAccount = (int) (bank.size() * Math.random());
                  double amount = MAX_AMOUNT * Math.random();
                  bank.transfer(fromAccount, toAccount, amount);
                  Thread.sleep((int) (DELAY * Math.random()));
               }
            }
            catch (InterruptedException e)
            {
            }            
         };
         Thread t = new Thread(r);
         t.start();
      }
   }
}

运行结果如下:

 

 

 

测试程序2:

l  在Elipse环境下调试教材655页程序14-8,结合程序运行结果理解程序;

l  掌握synchronized在多线程同步中的应用。

package synch2;

import java.util.*;

/**
 * A bank with a number of bank accounts that uses synchronization primitives.
 * @version 1.30 2004-08-01
 * @author Cay Horstmann
 */
public class Bank
{
   private final double[] accounts;

   /**
    * Constructs the bank.
    * @param n the number of accounts
    * @param initialBalance the initial balance for each account
    */
   public Bank(int n, double initialBalance)
   {
      accounts = new double[n];
      Arrays.fill(accounts, initialBalance);
   }

   /**
    * Transfers money from one account to another.
    * @param from the account to transfer from
    * @param to the account to transfer to
    * @param amount the amount to transfer
    */
   public synchronized void transfer(int from, int to, double amount) throws InterruptedException
   {
      while (accounts[from] < amount)
         wait();
      System.out.print(Thread.currentThread());
      accounts[from] -= amount;
      System.out.printf(" %10.2f from %d to %d", amount, from, to);
      accounts[to] += amount;
      System.out.printf(" Total Balance: %10.2f%n", getTotalBalance());
      notifyAll();
   }

   /**
    * Gets the sum of all account balances.
    * @return the total balance
    */
   public synchronized double getTotalBalance()
   {
      double sum = 0;

      for (double a : accounts)
         sum += a;

      return sum;
   }

   /**
    * Gets the number of accounts in the bank.
    * @return the number of accounts
    */
   public int size()
   {
      return accounts.length;
   }
}
package synch2;

/**
 * This program shows how multiple threads can safely access a data structure,
 * using synchronized methods.
 * @version 1.31 2015-06-21
 * @author Cay Horstmann
 */
public class SynchBankTest2
{
   public static final int NACCOUNTS = 100;
   public static final double INITIAL_BALANCE = 1000;
   public static final double MAX_AMOUNT = 1000;
   public static final int DELAY = 10;

   public static void main(String[] args)
   {
      Bank bank = new Bank(NACCOUNTS, INITIAL_BALANCE);
      for (int i = 0; i < NACCOUNTS; i++)
      {
         int fromAccount = i;
         Runnable r = () -> {
            try
            {
               while (true)
               {
                  int toAccount = (int) (bank.size() * Math.random());
                  double amount = MAX_AMOUNT * Math.random();
                  bank.transfer(fromAccount, toAccount, amount);
                  Thread.sleep((int) (DELAY * Math.random()));
               }
            }
            catch (InterruptedException e)
            {
            }
         };
         Thread t = new Thread(r);
         t.start();
      }
   }
}

运行结果如下:

 

 

 

测试程序3:

l  在Elipse环境下运行以下程序,结合程序运行结果分析程序存在问题;

l  尝试解决程序中存在问题。

package test2;
class Cbank
{
     private static int s=2000;
     public  static void sub(int m)
     {
           int temp=s;
           temp=temp-m;
          try {
                 Thread.sleep((int)(1000*Math.random()));
               }
           catch (InterruptedException e)  {              }
              s=temp;
              System.out.println("s="+s);
          }
    }


class Customer extends Thread
{
  public void run()
  {
   for( int i=1; i<=4; i++)
     Cbank.sub(100);
    }
 }
public class Thread3
{
 public static void main(String args[])
  {
   Customer customer1 = new Customer();
   Customer customer2 = new Customer();
   customer1.start();
   customer2.start();
  }
}

运行结果如下:

 

 

 

实验2 编程练习

利用多线程及同步方法,编写一个程序模拟火车票售票系统,共3个窗口,卖10张票,程序输出结果类似(程序输出不唯一,可以是其他类似结果)。

Thread-0窗口售:第1张票

Thread-0窗口售:第2张票

Thread-1窗口售:第3张票

Thread-2窗口售:第4张票

Thread-2窗口售:第5张票

Thread-1窗口售:第6张票

Thread-0窗口售:第7张票

Thread-2窗口售:第8张票

Thread-1窗口售:第9张票

Thread-0窗口售:第10张票

 

public class Demo {
    public static void main(String[] args) {
    mythread mythread=new mythread();
    Thread t1=new Thread(mythread);
    Thread t2=new Thread(mythread);
    Thread t3=new Thread(mythread);
    t1.start();
    t2.start();
    t3.start();
}
}
class mythread implements Runnable{
    int t=1;
    boolean flag=true;
    @Override
    public void run() {
        while(flag) {
            try {
                Thread.sleep(50);
            }catch(InterruptedException e)
            {
                e.printStackTrace();
            }
            synchronized (this) {
            if(t<=10) {
        // TODO Auto-generated method stub
                 System.out.println(Thread.currentThread().getName() + "窗口售:第" + t + "张票");
                 t++;
            }
            if(t>10) {
                flag=false;
            }
            }
        }
    
    }
    
}

运行结果如下:

 

 结对编程时照片:

 

 

 

实验总结:

       本周学习了同步线程的相关问题,这也是我们最后一次实验,在这周的学习中我们学习了并发多线程,学习了锁对象、synchronized关键字等。

posted @ 2019-12-23 21:01  石欣钰  阅读(177)  评论(1编辑  收藏  举报