«Белорусский государственный университет информатики и Радиоэлектроники»

«Белорусский государственный университет информатики и Радиоэлектроники»

Отчет

по лабораторным работам:

«2-3»

Выполнила:

Ст. гр.042801

Степанов А.А.

Проверил:

Величкевич И.О.

Минск 2012

План Выполнения работы:

1) Теория

2) Написанние исходного кода классов

3) Добавление нескольких паралельных потоков для изучения процесса мультипоточности работы программы

4) Реализация (реализация происходит в среде Eclipse в OS linux Ubuntu 12.10 c использованием java 6 версии)

5) Скрины

6) Выводы. Оценка проделанной работы

Класс является описываемой на языке терминологии (пространства имён) исходного кода моделью ещё не существующей сущности (объекта). Фактически он описывает устройство объекта, являясь своего рода чертежом. Экземпляр класса - это объект. Объект - это совокупность данных (свойств) и функций (методов) для их обработки.

Давайте так же выясним, что подразумевает под сабой наследование. Наследование (inheritance) - это процесс, посредством которого один объект может приобретать свойства другого. Точнее, объект может наследовать основные свойства другого объекта и добавлять к ним черты, характерные только для него. Наследование позволяет поддерживать концепцию иерархии классов. Применение иерархии классов делает управляемыми большие потоки информации. Без использования иерархии классов, для каждого объекта пришлось бы задать все характеристики, которые бы полностью его определяли. Однако при использовании наследования можно описать объект путём определения того общего класса (или классов), к которому он относится, с теми специальными чертами, которые делают объект уникальным.

Теперь поговорим о таком важном понятии, как модификаторы доступа. Модификаторы доступа можно рассматривать как с позиции инкапсуляции так и наследования. Если рассматривать с позиции наследования, то модификаторы доступа позволяют путем установки доступа указать члены класса, которые будут наследоваться классом наследником автоматически, а какие нет. Например, переменная или метод, объявленная как public в данном классе будет автоматически перениматься в классе потомке. Существует 3 модификатора доступа: public (без ограничений), private(область доступа только из данного класса) и protected(область доступа из данного класса и его потомков).

На наследование накладывается ряд таких ограничений как: в Java запрещено множественное наследование, при наследование если класс-родитель имеет одинаковые по названию поля или методы с классом-потомком, то происходит сокрытие имен. Для переопредееления метода из базового класса в классе-потомке существует служебное слово Override. Если нужно запретить переопределение (overriding) метода во всех порожденных классах, то этот метод можно описать как final. Кроме того, ключевое слово final может применяться к классам. Это означает, что данный класс не может быть унаследован другим классом.

//----------------------

Collection представляет собой группу объектов, часто называемых элементами. Некоторые реализации данного интерфейса позволяют дублирование содержащихся элементов, а некоторые нет. Некоторые хранят объекты в упорядоченном виде, а некоторые - в неупорядоченном.

List — это список объектов. Объекты можно добавлять в список (метод add()), заменять в списке (метод set()), удалять из списка (метод remove()), извлекать (метод get()). Существует также возможность организации прохода по списку при помощи итератора. Среди реализаций этого интерфейса в составе JDK имеются классы ArrayList и LinkedList.

Set — множество объектов. Те же возможности, что и у List, но объект может входить в множество только один раз. При этом напрямую получить конкретный объект из множества нельзя, можно только проверить, входит ли данный объект в множество (метод contains()). Однако можно получить итератор, который содержит все объекты из множества. Классы, реализующие интерфейс: HashSet, TreeSet.

Map — отображение или ассоциативный массив. В Map добавляют не отдельные объекты, а пары объектов ("ключ-значение"). Соответственно есть операции поиска значения по ключу. Добавление пары с уже существующим в Map ключем приводит к замене, а не к добавлению. Из отображения (Map) можно получить множество (Set) ключей и список (List) значений. Классы, реализующие интерфейс: HashMap и TreeMap.

//-------------------------------

Создание потоков

Создатели Java милостиво предоставили две возможности создания потоков: реализовать(implementing) интерфейс и расширить(extending) класс. Расширение класса это путь наследования методов и переменных класса родителя. В этом случае можно наследоваться только от одного родительского класса. Это ограничение внутри Java можно побороть реализацией интерфейса, который является наиболее распространённым способом создания потоков. (Заметим, что способ наследования позволяет только запустить класс как поток. Это позволяет классу только выполнить start() и т.п.).

Интерфейсы дают возможность программистам заложить фундамент одного класса. Они используются для разработки требований к набору классов для реализации. Интерфейс устанавливает правила. Разные наборы классов, которые реализуют интерфейс, должны следовать этим правилам.

Есть некоторые отличия между классом и интерфейсом. Во-первых, интерфейс может только содержать абстрактные методы и/или static final переменные (константы). Классы, с другой стороны, могут реализовывать методы и содержать переменные, которые не выступают в качестве констант. Во-вторых, интерфейс не может реализовывать никаких методов. Класс, который реализовывает интерфейс, должен реализовать все методы, которые описаны в интерфейсе. У интерфейса есть возможность расширяться за счёт других интерфейсов, и (в отличие от классов) могут расширяться от нескольких интерфейсов. К тому же, экземпляр интерфейса не может быть создан, используя, оператор new; например, Runnable a = new Runnable(); не разрешается.

Для первого способа создания потока необходимо просто наследоваться от класса Thread. Делайте так, только если классу нужно только выполниться как отдельному потоку и никогда не понадобиться наследоваться от другого класса. Класс Thread определён в пакете java.lang, который необходимо импортировать, что бы наши классы знали о его описании:

import java.lang.*;

public class Counter extends Thread {

public void run() {

....

}

}

Пример выше создаёт новый класс Counter, который расширяет класс Thread и подменяет метод Thread.run() для своей реализации. В методе run() происходит вся работа класса Counter как потока. Такой же класс можно создать, реализуя интерфейс Runnable:

import java.lang.*;

public class Counter implements Runnable {

Thread T;

public void run() {

....

}

}

Здесь осуществляется абстрактный метод run(), который описан в интерфейсе Runnable. Отметим, что у нас есть экземпляр класса Thread, переменная класса Counter. Единственное отличие этих двух методов заключается в том, что реализация Runnable является более гибкой для создания класса Counter. В примере, который описан выше, есть возможность расширения класса Counter, если в этом есть такая необходимость. Большинство классов, которые должны выполняться как потоки, реализуют Runnable, поскольку они, вероятно, могут расширить свою функциональность за счёт другого класса.

Не подумайте, что интерфейс Runnable выполняет какую-то реальную работу, когда поток запускается. Это всего лишь класс, созданный для того, что бы дать представление о классе Thread. На самом деле, это очень небольшой, содержащий только один абстрактный метод интерфейс. Это описание интерфейса Runnable, взятое из исходных кодов Java:

package java.lang;

public interface Runnable {

public abstract void run();

}

Это и всё, что есть в интерфейсе Runnable. Интерфейс – это всего лишь описание, которое классы должны реализовать. Итак, Runnable, заставляет только запустить метод run(). Вследствие этого, большая часть работы полагается на класс Thread. Более пристальный взгляд на класс Thread даст представление о том, что на самом деле происходит:

public class Thread implements Runnable {

...

public void run() {

if (target!= null) {

target.run();

}

}

...

}

Во фрагменте кода, который представлен выше видно, что класс Thread, так же реализует интерфейс Runnable. Thread.run() выполняет проверку, что бы удостовериться в том, что этот класс (класс, который выполняется как поток) не равен null, и только потом выполняет метод run(). Когда это произойдёт, то метод run() запустит поток.

Запуск и остановка

Различные способы создания объектов потока сейчас очевидны, мы продолжим дискуссию о реализации потоков, начиная с путей запуска и остановки их, используя, маленький applet, который содержит поток для иллюстрации этих механизмов:

CounterThread Example and Source code

Апплет выше, начнёт отсчёт с нуля и будет отображать это и на экране, и в консоль. На первый взгляд может сложиться впечатление, что программа начинает отсчёт и показывает каждую цифру, но это не так. При более внимательном рассмотрении этого апплета будет выявлено, как на самом деле работает этот апплет.

В этом случае, класс CounterThread был вынужден реализовать интерфейс Runnnable, что бы дальше была возможность расширить класс Applet. Все апплеты начинают свою работу с метода init(), переменная Cout инициализируется нулём и создаётся новый объект класса Thread. Передавая this в конструктор класса Thread, таким образом, новый поток будет знать какой объект запускается. В этом случает this это ссылка на CounterThread. После того как поток создан его нужно запустить. Вызываем метод start(), который в свою очередь вызывает метод run() объекта CounterThread, то есть CounterThread.run(). Сразу выполниться метод start() и в это же время начнёт свою работу поток. Заметим, что в методе run() бесконечный цикл. Он бесконечен, потому что, как только выполниться метод run(), то поток закончит работу. Метод run() будет инкрементировать переменную Count, ожидать(sleep) 10 секунд и посылать запрос на обновление экрана апплета.

Заметим, что вызова метода sleep именно в потоке является очень важным. Если это не так, то программа займёт всё процессорное время для своего процесса и не даст возможности любым другим методам, например методам, выполниться. Другой способ остановить выполнение потока это вызвать метод stop(). В данном примере, поток останавливается, когда происходит нажатие мыши в пределах апплета. В зависимости от скорости компьютера, на котором запущен апплет, не все числа будут отображены, потому что инкрементирование происходит независимо от прорисовки апплета. Апплет может не обновляться после каждого запроса на прорисовку, так как ОС может поставить запрос в очередь запросов и последующие запросы на обновление будут удовлетворены с одним запросом. Пока запросы на перерисовку собираются в очередь, переменная Count продолжает увеличиваться, но не отображается.

Приостановка и возобновление

Когда поток остановлен с использованием метода stop() он уже не может быть возобновлён с использованием метода start(), сразу после вызова метода stop() происходит уничтожение выполняющегося потока. Вместо этого вы можете приостановить выполнение потока, используя метод sleep() на определённый отрезок времени и потом выполнение потока продолжится, когда выйдет время. Но это не самое лучшее решение, если поток необходимо запустить, когда произойдёт определённое условие. Для этого, используется метод suspend(), который даёт возможность временно прекратить выполнение потока и метод resume(), который позволяет продолжить выполнение потока. Следующий апплет является изменением апплета, который был дан выше, но с использованием методов suspend() и resume():

public class CounterThread2 extends Applet implements Runnable

{

Thread t;

int Count;

boolean suspended;

public boolean mouseDown(Event e,int x, int y)

{

if(suspended)

t.resume();

else

t.suspend();

suspended =!suspended;

return true;

}

...

}

CounterThread2 Example and Source code

Для того чтобы сохранить текущее состояние апплета используется логическая(boolean) переменная suspended. Характеристики разных состояний апплета является важной частью, потому что некоторые методы могут выкидывать исключения, если они вызываются не из того состояния. Например, если поток запущен и остановлен, вызов метода start() приведёт к исключению IllegalThreadStateException.

Планирование

В Java есть Планировщик Потоков(Thread Scheduler), который контролирует все запущенные потоки во всех программах и решает, какие потоки должны быть запущены, и какая строка кода выполняться. Существует две характеристики потока, по которым планировщик идентифицирует процесс. Первая, более важная, это приоритет потока, другая, является-ли поток демоном(daemon flag). Простейшее правило планировщика, это если запущены только daemon потоки, то Java Virtual Machine (JVM) вызгрузиться. Новые потоки наследуют приоритет и daemon flag от потока, который его создал. Планировщик определяет какой поток должен быть запущен, анализируя приоритет всех потоков. Потоку с наивысшим приоритетом позволяется выполниться раньше, нежели потокам с более низкими приоритетами.

Планировщик может быть двух видов: с преимуществом и без. Планировщик с преимуществом предоставляет определённый отрезок времени для всех потоков, которые запущены в системе. Планировщик решает, какой поток следующий запуститься или возобновить работу через некоторый постоянный период времени. Когда поток запуститься, через этот определённый промежуток времени, то выполняющийся поток будет приостановлен и следующий поток возобновит свою работу. Планировщик без приоритета решает, какой поток должен запуститься и выполняться до того, пока не закончит свою работу. Поток имеет полный контроль над системой настолько долго, сколько ему захочется. Метод yield() можно использовать для того чтобы принудить планировщик выполнить другой поток, который ожидает своей очереди. В зависимости от системы, на которой запущена Java, планировщик может быть либо с преимуществом, либо без него.

Приоритеты

Планировщик определяет, какой поток должен запуститься, основываясь на номер приоритета, назначенный каждому потоку. Приоритет потока может принимать значения от 1 до 10. По умолчанию, значение приоритета для потока является Thread.NORM_PRIORITY, которому соответствует значение 5. Так же доступны две других static переменных: Thread.MIN_PRIORITY, значение 1, и Thread.MAX_PRIORITY – 10. Метод getPriority() может использоваться для получения текущего значения приоритета соответствующего потока.

Исходный код утилиты

<MainClass>

import java.util.ArrayList;

import university.StateUniversity;

import university.department.Department;

import university.faculty.Faculty;

public class MainClass {

/**

* @param args

*/

public static void main(String[] args) {

StateUniversity.printWords();

// TODO Auto-generated method stub

ArrayList<StateUniversity> stU = createStateUniversity();

//System.out.println(stU.size());

System.out.println(stU.get(0).getAdress());

System.out.println(stU.get(0).getName());

System.out.println(stU.get(0).getFree());

System.out.println(stU.get(0).getpay());

System.out.println(stU.get(0).getFacultyList().get(0).getSpecialtyName());

//System.out.println(stU.get(0).getFacultyList().get(0).getSpecialtyNameToString());

System.out.println(stU.get(0).getFacultyList().get(0).getName());

System.out.println(stU.get(0).getFacultyList().get(0).getNumOfGroups());

System.out.println(stU.get(0).getDepartmentList().get(0).getSubjectList());

}

public static ArrayList<StateUniversity> createStateUniversity(){

ArrayList<StateUniversity> universities = new ArrayList<StateUniversity>();

StateUniversity stateUniversity = new StateUniversity();

stateUniversity.setPay(100);

stateUniversity.setFree(90);

stateUniversity.setName("BSUIR");

stateUniversity.setAdress("brovki str.");

ArrayList<Faculty> listOfFaculty = new ArrayList<Faculty>();

Faculty FRE = new Faculty("FRE");

FRE.setNumOfGroups(20);

ArrayList<String> specialtyName = new ArrayList<String>();

specialtyName.add("RI");

specialtyName.add("RT");

FRE.setSpecialtyName(specialtyName);

listOfFaculty.add(FRE);

ArrayList<Department> listOfDep = new ArrayList<Department>();

Department RTU = new Department("RTU");

RTU.addSubject("TOR");

RTU.addSubject("OAIS");

ArrayList<String> listDissert = new ArrayList<String>();

listDissert.add("ddgdfgdf");

listDissert.add("sdfdsfdf");

RTU.setListOfDissert(listDissert);

listOfDep.add(RTU);

ArrayList<String> listOfDissert = new ArrayList<String>();

listOfDissert.add("aasdaasdsa");

ArrayList<String> subjectList = new ArrayList<String>();

subjectList.add("A");

Department QWE = new Department("QWE", listOfDissert, subjectList, 3);

stateUniversity.setDepartmentList(listOfDep);

stateUniversity.setFacultyList(listOfFaculty);

universities.add(stateUniversity);

return universities;

}

}

//---------------------------------------------------------------------------------

<EducationalInstitution>

package university;

public abstract class EducationalInstitution {

/**

* @param args

*/

protected String name;

protected String adress;

public String getName() {

return name;

}

public void setName(String name) {

this. name = name;

}

public String getAdress() {

return adress;

}

public void setAdress(String adress) {

this. adress = adress;

}

public abstract void printNameAndAdress();

public abstract String getNameAndAdress();

}

//-------------------------------------------------------------------------

<StateUniversity>

package university;

public class StateUniversity extends University {

/**

* @param args

*/

private int pay;

private int free;

public static final int u = 8;

public static void printWords() {

System. out. println("Welcome to university!!!");

}

public int getpay() {

return pay;

}

public void setPay(int pay) {

this. pay = pay;

}

public int getFree() {

return free;

}

public void setFree(int free) {

this. free = free;

}

public String getName() {

return super. getName() + "!!!";

}

}

//--------------------------------------------------------------

<University>

package university;

import java.util.ArrayList;

import university.department.Department;

import university.faculty.Faculty;

public class University extends EducationalInstitution{

/**

* @param args

*/

private ArrayList<Faculty> facultyList;

private ArrayList<Department> departmentList;

public void setFacultyList(ArrayList<Faculty> facultyList) {

this.facultyList = facultyList;

}

public ArrayList<Faculty> getFacultyList() {

return facultyList;

}

public ArrayList<Department> getDepartmentList() {

return departmentList;

}

public void setDepartmentList(ArrayList<Department> departmentList) {

this.departmentList = departmentList;

}

@Override

public void printNameAndAdress() {

System.out.println(getName() + " - " + getAdress());

}

@Override

public String getNameAndAdress() {

// TODO Auto-generated method stub

return name + " " + adress;

}

}

///////////////////////////////////////////////////////////////////////////////

<Department>

package university.department;

import java.util.ArrayList;

public class Department implements ScienceWork, EducationWork {

/**

* @param args

*/

private String nameDep;

private ArrayList<String> listOfDissert;

private ArrayList<String> subjectList = new ArrayList<String>();

private int scienceDoctors;

public Department(String nameDep){

this. nameDep = nameDep;

}

public Department(String nameDep, ArrayList<String> listOfDissert,

ArrayList<String> subjectList, int scienceDoctors) {

this. nameDep = nameDep;

this. listOfDissert = listOfDissert;

this. subjectList = subjectList;

this. scienceDoctors = scienceDoctors;

}

@Override

public ArrayList<String> getSubjectList() {

return subjectList;

}

@Override

public void addSubject(String subject) {

subjectList.add(subject);

}

@Override

public ArrayList<String> getListOfDissert() {

return listOfDissert;

}

@Override

public int getScienceDoctors() {

return scienceDoctors;

}

public void setListOfDissert(ArrayList<String> listOfDissert){

this. listOfDissert = listOfDissert;

}

public void setScienceDoctors(int scienceDoctors){

this. scienceDoctors = scienceDoctors;

}

public String getNameDep(){

return nameDep;

}

}

//_-------------------------------------------------------

<EducationWork>

package university.department;

import java.util.ArrayList;

public interface EducationWork {

public ArrayList<String> getSubjectList();

public void addSubject(String subject);

}

//__________________

<ScienceWork>

package university.department;

import java.util.ArrayList;

public interface ScienceWork {

public ArrayList<String> getListOfDissert();

public int getScienceDoctors();

}

//

<Faculty>

package university.faculty;

import java.util.ArrayList;

import java.util.Arrays;

public class Faculty {

/**

* @param args

*/

private String facName;

private ArrayList<String> specialtyName;

private int numOfGroups;

public Faculty(String facName){

this.facName = facName;

}

public void setSpecialtyName(ArrayList<String> specialtyName){

this.specialtyName = specialtyName;

}

public void setNumOfGroups(int numOfGroups){

this.numOfGroups = numOfGroups;

}

public String getName(){

return facName;

}

public int getNumOfGroups() {

return numOfGroups;

}

public ArrayList<String> getSpecialtyName() {

return specialtyName;

}

public String getSpecialtyNameToString(){

return Arrays.toString(specialtyName.toArray());

}

}

Дата добавления: 2015-09-29