Конспект лекций по курсу Выбранные вопросы информатики (часть 2) для специальности Информатика Графика
| Вид материала | Конспект |
- Конспект лекций по курсу Выбранные вопросы информатики (часть 1) для специальности, 2228.49kb.
- Конспект лекций по курсу "Начертательная геометрия и инженерная графика" Кемерово 2002, 786.75kb.
- Вопросы к зачету по курсу лекций "Информатика" для студентов Iкурса кафедры аэту iсеместр., 18.81kb.
- Конспект лекций по курсу "Информатика и использование компьютерных технологий в образовании", 1797.24kb.
- Программа «Компьютерная графика» кружковая работа по дисциплине «информатика» для специальности, 186.22kb.
- Конспект лекций по дисциплине информатика для студентов заочного отделения, 649.48kb.
- Конспект лекций по курсу «бизнес-планирование в условиях рынка», 461.46kb.
- Конспект лекций для специальности «Прикладная информатика в экономике», 1468.57kb.
- Конспект лекций по дисциплине «Высокоуровневые методы информатики и программирования», 2453.58kb.
- Конспект лекций по курсу «Организация производства», 2034.84kb.
Описание исходного текста приложения MenuApp
Как мы уже говорили, приложение MenuApp работает автономно. Поэтому мы импортируем только класс java.awt.*, необходимый для работы с окнами:
import java.awt.*;
В нашем приложении определено три класса - MenuApp, MainFrameWnd и MessageBox.
Класс MenuApp
В главном классе приложения MenuApp мы определили только один метод main. Этот метод получает управление при запуске приложения.
Первым делом метод main создает объект класса MainFrameWnd, определенного в нашем приложении:
MainFrameWnd frame =
new MainFrameWnd("MenuApp");
Этот класс, созданный на базе класса Frame, определяет поведение главного окна нашего приложения.
На втором шаге метод init настраивает размеры главного окна с учетом размеров внешней рамки и заголовка окна:
frame.setSize(frame.getInsets().left +
frame.getInsets().right + 320,
frame.getInsets().top +
frame.getInsets().bottom + 240);
Поля left и right объекта класса Insets, ссылку на который возвращает метод getInsets, содержат ширину левой и правой части рамки окна, соответственно. Поле top содержит высоту верхней части рамки окна с учетом заголовка, а поле bottom - высоту нижней части рамки окна.
Для отображения окна фрейма мы вызываем метод show, как это показано ниже:
frame.show();
Класс MainFrameWnd
Класс MainFrameWnd создан на базе класса Frame:
class MainFrameWnd extends Frame
{
. . .
}
В нем мы определили три поля, конструктор, методы paint, handleEvent и action.
Поля класса MainFrameWnd
Поле mbMainMenuBar предназанчено для хранения ссылки на главное меню приложения, создаваемое как объект класса MenuBar:
MenuBar mbMainMenuBar;
Поля mnFile и mnHelp хранят ссылки на меню File и Help, соответственно:
Menu mnFile;
Menu mnHelp;
Данные меню создаются на базе класса Menu.
Конструктор класса MainFrameWnd
В качестве единственного параметра конструктору класса MainFrameWnd передается заголовок создаваемого окна. В первой исполняемой строке наш конструктор вызывает конструктор из базового класса, передавая ему строку заголовка через параметр:
public MainFrameWnd(String sTitle)
{
super(sTitle);
. . .
}
Далее конструктор определяет размеры окна, вызывая для него метод setSize:
setSize(400, 200);
Затем мы устанавливаем для нашего окна желтый цвет фона и черный цвет изображения:
setBackground(Color.yellow);
setForeground(Color.black);
По умолчанию для окон класса Frame устанавливается режим добавления компонент BorderLayout. Мы изменяем этот режим на FlowLayout, вызывая метод setLayout:
setLayout(new FlowLayout());
Далее конструктор приступает к формированию главного меню окна. Это меню создается как объект класса MenuBar:
mbMainMenuBar = new MenuBar();
Затем мы создаем и наполняем меню "File":
mnFile = new Menu("File");
mnFile.add("New");
mnFile.add("-");
mnFile.add("Exit");
Это меню создается на базе класса Menu. Обратите внимание, что между строками New и File расположен разделитель.
Аналогичным образом мы добавляем в главное меню другое меню - "Help":
mnHelp = new Menu("Help");
mnHelp.add("Content");
mnHelp.add("-");
mnHelp.add("About");
После своего окончательного формирования меню "File" и "Help" добавляются в главное меню окна mbMainMenuBar:
mbMainMenuBar.add(mnFile);
mbMainMenuBar.add(mnHelp);
И, наконец, когда главное меню будет сформировано, оно подключается к окну вызовом метода setMenuBar, как это показано ниже:
setMenuBar(mbMainMenuBar);
Метод paint
Метод paint получает в качестве параметра ссылку на контекст отображения, пригодный для рисования в нашем окне. Пользуясь этим контекстом, мы устанавливаем шрифт текста и рисуем текстовую строку. Затем мы вызываем метод paint из базового класса Frame, на основе которого создан наш класс MainFrameWnd:
public void paint(Graphics g)
{
g.setFont(new Font("Helvetica", Font.PLAIN, 12));
g.drawString("Frame window", 10, 70);
super.paint(g);
}
Метод handleEvent
Для того чтобы определить реакцию окна на попытку пользователя закрыть окно с помощью органов управления, расположенных в заголовке окна, или другим способом, мы переопределили метод handleEvent.
При получении кода события Event.WINDOW_DESTROY (удаление окна) мы скрываем окно, вызывая метод setVisible с параметром false.
Затем с помощью статического метода exit класса System мы завершаем работу интерпретатора:
public boolean handleEvent(Event evt)
{
if(evt.id == Event.WINDOW_DESTROY)
{
setVisible(false);
System.exit(0);
return true;
}
else
return super.handleEvent(evt);
}
Метод action
Этот метод обрабатывает события, возникающие при выборе строка из меню.
В начале своей работы метод action проверяет, действительно ли событие вызвано меню:
MenuItem mnItem;
if(evt.target instanceof MenuItem)
{
. . .
}
return false;
Если это так, в поле mnItem сохраняется ссылка на элемент меню, вызвавший событие:
mnItem = (MenuItem)evt.target;
Тем не менее, для определения строки, выбранной пользователем, нам достаточно проанализировать второй параметр метода action:
if(obj.equals("Exit"))
{
System.exit(0);
}
else if(obj.equals("New"))
{
MessageBox mbox;
mbox = new MessageBox("Item New selected", this, "Dialog from Frame", true);
mbox.show();
}
else if(obj.equals("Content"))
{
. . .
}
else if(obj.equals("About"))
{
. . .
}
В данном случае второй параметр метода action будет представлять собой ссылку на строку, выбранную из меню, поэтому для определения выбранной строки мы можем выполнить простое сравнение методом equals.
Если пользователь выбрал из меню File строку Exit, мы вызываем метод System.exit, предназначенный для завершения работы виртуальной машины Java.
В том случае когда пользователь выбирает любую другую строку из меню, метод action создает диалоговую панель на базе определенного нами класса MessageBox. В этой диалоговой панели отображаетя название выбранной строки меню.
Заметим, что сразу после создания конструктором диалоговая панель не появляется на экране. Мы отображаем ее, вызывая метод show.
Класс MessageBox
Для отображения названий выбранных строк меню мы создаем диалоговую панель, определив свой класс MessageBox на базе класса Dialog, как это показано ниже:
class MessageBox extends Dialog
{
. . .
}
В классе MessageBox есть два поля, конструктор, методы handleEvent и action.
Поля класса MessageBox
Внутри диалоговой панели мы расположили текстовое поле класса Label, предназначенное для отображения сообщения, и кнопку с надписью OK, с помощью которой можно завершить работу диалоговой панели.
Ссылка на текстовое поле хранится в поле lbMsg, на кнопку - в поле btnOK.
Конструктор класса MessageBox
Наш конструктор создает диалоговую панель с заданным сообщением внутри нее. Ссылка на строку сообщения передается конструктору через первый параметр. Остальные параметры используются конструктором базового класса Dialog для создания диалоговой панели:
super(parent, sTitle, modal);
После вызова конструктора из базового класса наш конструктор устанавливает размеры окна созданной диалоговой панели, вызывая метод resize:
resize(200, 100);
Отменяя установленный по умолчанию режим размещения компонент BorderLayout, конструктор устанавливает режим GridLayout:
setLayout(new GridLayout(2, 1));
Окно диалоговой панели при этом разделяется на две части по горизонтали. В верхнюю часть добавляется текстовое поле для отображения сообщения, в нижнюю - кнопка OK:
lbMsg = new Label(sMsg, Label.CENTER);
add(lbMsg);
btnOK = new Button("OK");
add(btnOK);
Метод handleEvent класса MessageBox
Когда пользователь пытается закрыть окно диалоговой панели, например, сделав двойной щелчок левой клавишей мыши по системному меню или одиночный щелчок по кнопке удаления окна, возникает событие Event.WINDOW_DESTROY. Мы его обрабатываем следующим образом:
if(evt.id == Event.WINDOW_DESTROY)
{
dispose();
return true;
}
else
return super.handleEvent(evt);
Вызывая метод dispose, мы удаляем окно диалоговой панели и освобождаем все связанные с ним ресурсы.
Метод action класса MessageBox
Если пользователь нажимает кнопку OK, расположенную в окне диалоговой панели, метод action вызывает для панели метод dispose, удаляя эту панель с экрана и из памяти:
if(evt.target.equals(btnOK))
{
dispose();
}
Лекция 3
Многопоточность и легковесные процессы
Многопоточность
Наверное, сегодня уже нет необходимости объяснять, что такое многопоточность. Все современные операционные системы, такие как Windows 95, Windows NT, OS/2 или UNIX способны работать в многопоточном режиме, повышая общую производительность системы за счет эффективного распараллеливания выполняемых потоков. Пока один поток находится в состоянии ожидания, например, завершения операции обмена данными с медленным периферийным устройством, другой может продолжать выполнять свою работу.
Пользователи уже давно привыкли запускать параллельно несколько приложений для того чтобы делать несколько дел сразу. Пока одно из них занимается, например, печатью документа на принтере или приемом электронной почты из сети Internet, другое может пересчитывать электронную таблицу или выполнять другую полезную работу. При этом сами по себе запускаемые приложения могут работать в рамках одного потока - операционная система сама заботится о распределении времени между всеми запущенными приложениями.
Создавая приложения для операционной системы Windows на языках программирования С или С++, вы могли решать многие задачи, такие как анимация или работа в сети, и без использования многопоточности. Например, для анимации можно было обрабатывать сообщения соответствующим образом настроенного таймера.
Приложениям Java такая методика недоступна, так как в этой среде не предусмотрено способов периодического вызова каких-либо процедур. Поэтому для решения многих задач вам просто не обойтись без многопоточности.
Процессы, потоки и приоритеты
Прежде чем приступить к разговору о многопоточности, следует уточнить некоторые термины.
Обычно в любой многопоточной операционной системе выделяют такие объекты, как процессы и потоки. Между ними существует большая разница, которую следует четко себе представлять.
Процесс
Процесс (process) - это объект, который создается операционной системой, когда пользователь запускает приложение. Процессу выделяется отдельное адресное пространство, причем это пространство физически недоступно для других процессов. Процесс может работать с файлами или с каналами связи локальной или глобальной сети. Когда вы запускаете текстовый процессор или программу калькулятора, вы создаете новый процесс.
Поток
Для каждого процесса операционная система создает один главный поток (thread ), который является потоком выполняющихся по очереди команд центрального процессора. При необходимости главный поток может создавать другие потоки, пользуясь для этого программным интерфейсом операционной системы.
Все потоки, созданные процессом, выполняются в адресном пространстве этого процесса и имеют доступ к ресурсам процесса. Однако поток одного процесса не имеет никакого доступа к ресурсам потока другого процесса, так как они работают в разных адресных пространствах. При необходимости организации взаимодействия между процессами или потоками, принадлежащими разным процессам, следует пользоваться системными средствами, специально предназначенными для этого.
Приоритеты потоков в приложениях Java
Если процесс создал несколько потоков, то все они выполняются параллельно, причем время центрального процессора (или нескольких центральных процессоров в мультипроцессорных системах) распределяется между этими потоками.
Распределением времени центрального процессора занимается специальный модуль операционной системы - планировщик. Планировщик по очереди передает управление отдельным потокам, так что даже в однопроцессорной системе создается полная иллюзия параллельной работы запущенных потоков.
Распределение времени выполняется по прерываниям системного таймера. Поэтому каждому потоку дается определенный интервал времени, в течении которого он находится в активном состоянии.
Заметим, что распределение времени выполняется для потоков, а не для процессов. Потоки, созданные разными процессами, конкурируют между собой за получение процессорного времени.
Каким именно образом?
Приложения Java могут указывать три значения для приоритетов потоков. Это NORM_PRIORITY, MAX_PRIORITY и MIN_PRIORITY.
По умолчанию вновь созданный поток имеет нормальный приоритет NORM_PRIORITY. Если остальные потоки в системе имеют тот же самый приоритет, то все потоки пользуются процессорным времени на равных правах.
При необходимости вы можете повысить или понизить приоритет отдельных потоков, определив для них значение приоритета, соответственно, MAX_PRIORITY или MIN_PRIORITY. Потоки с повышенным приоритетом выполняются в первую очередь, а с пониженным - только при отсутствии готовых к выполнению потоков, имеющих нормальный или повышенный приоритет.
Процессы, потоки и приоритеты
Прежде чем приступить к разговору о многопоточности, следует уточнить некоторые термины.
Обычно в любой многопоточной операционной системе выделяют такие объекты, как процессы и потоки. Между ними существует большая разница, которую следует четко себе представлять.
Процесс
Процесс (process) - это объект, который создается операционной системой, когда пользователь запускает приложение. Процессу выделяется отдельное адресное пространство, причем это пространство физически недоступно для других процессов. Процесс может работать с файлами или с каналами связи локальной или глобальной сети. Когда вы запускаете текстовый процессор или программу калькулятора, вы создаете новый процесс.
Поток
Для каждого процесса операционная система создает один главный поток (thread ), который является потоком выполняющихся по очереди команд центрального процессора. При необходимости главный поток может создавать другие потоки, пользуясь для этого программным интерфейсом операционной системы.
Все потоки, созданные процессом, выполняются в адресном пространстве этого процесса и имеют доступ к ресурсам процесса. Однако поток одного процесса не имеет никакого доступа к ресурсам потока другого процесса, так как они работают в разных адресных пространствах. При необходимости организации взаимодействия между процессами или потоками, принадлежащими разным процессам, следует пользоваться системными средствами, специально предназначенными для этого.
Приоритеты потоков в приложениях Java
Если процесс создал несколько потоков, то все они выполняются параллельно, причем время центрального процессора (или нескольких центральных процессоров в мультипроцессорных системах) распределяется между этими потоками.
Распределением времени центрального процессора занимается специальный модуль операционной системы - планировщик. Планировщик по очереди передает управление отдельным потокам, так что даже в однопроцессорной системе создается полная иллюзия параллельной работы запущенных потоков.
Распределение времени выполняется по прерываниям системного таймера. Поэтому каждому потоку дается определенный интервал времени, в течении которого он находится в активном состоянии.
Заметим, что распределение времени выполняется для потоков, а не для процессов. Потоки, созданные разными процессами, конкурируют между собой за получение процессорного времени.
Каким именно образом?
Приложения Java могут указывать три значения для приоритетов потоков. Это NORM_PRIORITY, MAX_PRIORITY и MIN_PRIORITY.
По умолчанию вновь созданный поток имеет нормальный приоритет NORM_PRIORITY. Если остальные потоки в системе имеют тот же самый приоритет, то все потоки пользуются процессорным времени на равных правах.
При необходимости вы можете повысить или понизить приоритет отдельных потоков, определив для них значение приоритета, соответственно, MAX_PRIORITY или MIN_PRIORITY. Потоки с повышенным приоритетом выполняются в первую очередь, а с пониженным - только при отсутствии готовых к выполнению потоков, имеющих нормальный или повышенный приоритет.
Реализация многопоточности в Java
Должны воспользоваться классом java.lang.Thread. В этом классе определены все методы, необходимые для создания потоков, управления их состоянием и синхронизации.
Как пользоваться классом Thread?
Есть две возможности.
Во-первых, вы можете создать свой дочерний класс на базе класса Thread. При этом вы должны переопределить метод run. Ваша реализация этого метода будет работать в рамках отдельного потока.
Во-вторых, ваш класс может реализовать интерфейс Runnable. При этом в рамках вашего класса необходимо определить метод run, который будет работать как отдельный поток.
Второй способ особенно удобен в тех случаях, когда ваш класс должен быть унаследован от какого-либо другого класса (например, от класса Applet) и при этом вам нужна многопоточность. Так как в языке программирования Java нет множественного наследования, невозможно создать класс, для которого в качестве родительского будут выступать классы Applet и Thread. В этом случае реализация интерфейса Runnable является единственным способом решения задачи.
Методы класса Thread
В классе Thread определены три поля, несколько конструкторов и большое количество методов, предназначенных для работы с потоками. Ниже мы привели краткое описание полей, конструкторов и методов.
С помощью конструкторов вы можете создавать потоки различными способами, указывая при необходимости для них имя и группу. Имя предназначено для идентификации потока и является необязательным атрибутом. Что же касается групп, то они предназначены для организации защиты потоков друг от друга в рамках одного приложения.
Методы класса Thread предоставляют все необходимые возможности для управления потоками, в том числе для их синхронизации.
Поля
Три статических поля предназначены для назначения приоритетов потокам.
NORM_PRIORITY
Нормальный
public final static int NORM_PRIORITY;
MAX_PRIORITY
Максимальный
public final static int MAX_PRIORITY;
MIN_PRIORITY
Минимальный
public final static int MIN_PRIORITY;
Конструкторы
Создание нового объекта Thread
public Thread();
Создвание нового объекта Thread с указанием объекта, для которого будет вызываться метод run
public Thread(Runnable target);
Аналогично предыдущему, но дополнительно задается имя нового объекта Thread
public Thread(Runnable target, String name);
Создание объекта Thread с указанием его имени
public Thread(String name);
Создание нового объекта Thread с указанием группы потока и объекта, для которого вызывается метод run
public Thread(ThreadGroup group,
Runnable target);
Аналогично предыдущему, но дополнительно задается имя нового объекта Thread
public Thread(ThreadGroup group, Runnable target, String name);
Создание нового объекта Thread с указанием группы потока и имени объекта
public Thread(ThreadGroup group, String name);
Методы
activeCount
Текущее количество активных потоков в группе, к которой принадлежит поток
public static int activeCount();
checkAccess
Текущему потоку разрешается изменять объект Thread
public void checkAccesss();
countStackFrames
Определение количества фреймов в стеке
public int countStackFrames();
currentThread
Определение текущего работающего потока
public static Thread currentThread();
destroy
Принудительное завершение работы потока
public void destroy();
dumpStack
Вывод текущего содержимого стека для отладки
public static void dumpStack();
enumerate
Получение всех объектов Tread данной группы
public static int enumerate(Thread tarray[]);
getName
Определение имени потока
public final String getName();
getPriority
Определение текущего приоритета потока
public final int getPriority();
getThreadGroup
Определение группы, к которой принадлежит поток
public final ThreadGroup getThreadGroup();
interrupt
Прерывание потока
public void interrupt();
interrupted
Определение, является ли поток прерванным
public static boolean interrupted();
isAlive
Определение, выполняется поток или нет
public final boolean isAlive();
isDaemon
Определение, является ли поток демоном
public final boolean isDaemon();
isInterrupted
Определение, является ли поток прерванным
public boolean isInterrupted();
join
Ожидание завершения потока
public final void join();
Ожидание завершения потока в течение заданного времени. Время задается в миллисекундах
public final void join(long millis);
Ожидание завершения потока в течение заданного времени. Время задается в миллисекундах и наносекундах
public final void join(long millis, int nanos);
resume
Запуск временно приостановленного потока
public final void resume();
run
Метод вызывается в том случае, если поток был создан как объект с интерфейсом Runnable
public void run();
setDaemon
Установка для потока режима демона
public final void setDaemon(boolean on);
setName
Устаовка имени потока
public final void setName(String name);
setPriority
Установка приоритета потока
public final void setPriority(int newPriority);
sleep
Задержка потока на заднное время. Время задается в миллисекундах и наносекундах
public static void sleep(long millis);
Задержка потока на заднное время. Время задается в миллисекундах и наносекундах
public static void sleep(long millis, int nanos);
start
Запуск потока на выполнение
public void start();
stop
Остановка выполнения потока
public final void stop();
Аварийная остановка выполнения потока с заданным исключением
public final void stop(Throwable obj);
suspend
Приостановка потока
public final void suspend();
toString
Строка, представляющая объект-поток
public String toString();
yield
Приостановка текущего потока для того чтобы управление было передано другому потоку
public static void yield();
Создание дочернего класса на базе класса Thread
Рассмотрим первый способ реализации многопоточности, основанный на наследовании от класса Thread. При использовании этого способа вы определяете для потока отдельный класс, например, так:
class DrawRectangles extends Thread
{
. . .
public void run()
{
. . .
}
}
Здесь определен класс DrawRectangles, который является дочерним по отношению к классу Thread.
Обратите внимание на метод run. Создавая свой класс на базе класса Thread, вы должны всегда определять этот метод, который и будет выполняться в рамках отдельного потока.
Заметим, что метод run не вызывается напрямую никакими другими методами. Он получает управление при запуске потока методом start.
Как это происходит?
Рассмотрим процедуру запуска потока на примере некоторого класса DrawRectangles.
Вначале ваше приложение должно создать объект класса Thread:
public class MultiTask2 extends Applet
{
Thread m_DrawRectThread = null;
. . .
public void start()
{
if (m_DrawRectThread == null)
{
m_DrawRectThread = new DrawRectangles(this);
m_DrawRectThread.start();
}
}
}
Создание объекта выполняется оператором new в методе start, который получает управление, когда пользователь открывает документ HTML с аплетом. Сразу после создания поток запускается на выполнение, для чего вызывается метод start.
Что касается метода run, то если поток используется для выполнения какой либо периодической работы, то этот метод содержит внутри себя бесконечный цикл. Когда цикл завершается и метод run возвращает управление, поток прекращает свою работу нормальным, не аварийным образом. Для аварийного завершения потока можно использовать метод interrupt.
Остановка работающего потока выполняется методом stop. Обычно остановка всех работающих потоков, созданных аплетом, выполняется методом stop класса аплета:
public void stop()
{
if (m_DrawRectThread != null)
{
m_DrawRectThread.stop();
m_DrawRectThread = null;
}
}
Напомним, что этот метод вызывается, когда пользователь покидает страницу сервера Web, содержащую аплет.
Реализация интерфейса Runnable
Описанный выше способ создания потоков как объектов класса Thread или унаследованных от него классов кажется достаточнао естественным. Однако этот способ не единственный. Если вам нужно создать только один поток, работающую одновременно с кодом аплета, проще выбрать второй способ с использованием интерфейса Runnable.
Идея заключается в том, что основной класс аплета, который является дочерним по отношению к классу Applet, дополнительно реализует интерфейс Runnable, как это показано ниже:
public class MultiTask extends
Applet implements Runnable
{
Thread m_MultiTask = null;
. . .
public void run()
{
. . .
}
public void start()
{
if (m_MultiTask == null)
{
m_MultiTask = new Thread(this);
m_MultiTask.start();
}
}
public void stop()
{
if (m_MultiTask != null)
{
m_MultiTask.stop();
m_MultiTask = null;
}
}
}
Внутри класса необходимо определить метод run, который будет выполняться в рамках отдельного потока. При этом можно считать, что код аплета и код метода run работают одновременно как разные потоки.
Для создания потока используется оператор new. Поток создается как объект класса Thread, причем конструктору передается ссылка на класс аплета:
m_MultiTask = new Thread(this);
При этом, когда поток запустится, управление получит метод run, определенный в классе аплета.
Как запустить поток?
Запуск выполняется, как и раньше, методом start. Обычно поток запускается из метода start аплета, когда пользователь отображает страницу сервера Web, содержащую аплет. Остановка потока выполняется методом stop.