- •724 Содержание
- •Глава 6. Интерфейсы и внутренние классы 139
- •У казания и ответы
- •Вопрос 3.2.
- •Вопрос 8.2.
- •Вопрос 8.3.
- •Вопрос 14.2.
- •Вопрос 21.5.
- •Ч асть 1. Основы языка java
- •Глава 1 введение в классы и объекты Основные понятия ооп
- •Язык Java
- •Нововведения версий 5.0 и 6.0
- •Простое приложение
- •Классы и объекты
- •Сравнение объектов
- •Консоль
- •Простой апплет
- •Задания к главе 1 Вариант a
- •Вариант b
- •Тестовые задания к главе 1
- •Вопрос 1.5.
- •Г лава 2 типы данных и операторы
- •Базовые типы данных и литералы
- •Документирование кода
- •Операторы
- •Классы-оболочки
- •Операторы управления
- •Массивы
- •Класс Маth
- •Управление приложением
- •Задания к главе 2 Вариант a
- •Вариант в
- •Тестовые задания к главе 2
- •Переменные класса и константы
- •Ограничение доступа
- •Конструкторы
- •Статические методы и поля
- •Модификатор final
- •Абстрактные методы
- •Модификатор native
- •Модификатор synchronized
- •Логические блоки
- •Перегрузка методов
- •Параметризованные классы
- •Параметризованные методы
- •Методы с переменным числом параметров
- •Перечисления
- •1 : Fpmi : Балаганов
- •Аннотации
- •Задания к главе 3 Вариант a
- •Вариант b
- •Тестовые задания к главе 3
- •Использование final
- •Использование super и this
- •Переопределение методов и полиморфизм
- •Методы подставки
- •Полиморфизм и расширяемость
- •Статические методы и полиморфизм
- •Абстракция и абстрактные классы
- •Класс Object
- •Клонирование объектов
- •“Сборка мусора” и освобождение ресурсов
- •Задания к главе 4 Вариант a
- •Вариант в
- •Тестовые задания к главе 4
- •Вопрос 4.7.
- •Г лава 5 проектирование классов Шаблоны проектирования grasp
- •Шаблон Expert
- •Шаблон Creator
- •Шаблон Low Coupling
- •Шаблон High Cohesion
- •Шаблон Controller
- •Шаблоны проектирования GoF
- •Порождающие шаблоны
- •К порождающим шаблонам относятся:
- •Шаблон Factory
- •Шаблон AbstractFactory
- •Шаблон Builder
- •Шаблон Singleton
- •Структурные шаблоны
- •К структурным шаблонам относятся:
- •Шаблон Bridge
- •Шаблон Decorator
- •Шаблоны поведения
- •К шаблонам поведения относятся:
- •Шаблон Command
- •Шаблон Strategy
- •Шаблон Observer
- •Тестовые задания к главе 5
- •Статический импорт
- •Внутренние классы
- •Внутренние (inner) классы
- •Вложенные (nested) классы
- •Анонимные (anonymous) классы
- •Задания к главе 6 Вариант а
- •Вариант b
- •Вариант c
- •Тестовые задания к главе 6
- •Вопрос 6.5.
- •Класс String
- •Классы StringBuilder и StringBuffer
- •Форматирование строк
- •Лексический анализ текста
- •Регулярные выражения
- •Интернационализация текста
- •Интернационализация чисел
- •Интернационализация дат
- •3 Апрель 2006 г.
- •Задания к главе 7 Вариант a
- •Вариант b
- •Тестовые задания к главе 7
- •Оператор throw
- •Ключевое слово finally
- •Собственные исключения
- •Наследование и исключения
- •Отладочный механизм assertion
- •Задания к главе 8
- •Байтовые и символьные потоки ввода/вывода
- •Предопределенные потоки
- •Сериализация объектов
- •Консоль
- •Класс Scanner
- •Архивация
- •Задания к главе 9 Вариант a
- •Вариант b
- •Вариант с
- •Тестовые задания к главе 9
- •Множества
- •Карты отображений
- •14El - найден по ключу '12'
- •Унаследованные коллекции
- •Класс Collections
- •Класс Arrays
- •Задания к главе 10 Вариант a
- •Вариант b
- •Тестовые задания к главе 10
- •Апплеты
- •Задания к главе 11
- •Тестовые задания к главе 11
- •Классы-адаптеры
- •Задания к главе 12
- •Тестовые задания к главе 12 Вопрос 12.1.
- •Вопрос 12.2.
- •Вопрос 12.3.
- •Вопрос 12.4.
- •Вопрос 12.5.
- •Г лава 13 элементы компоновки и управления
- •Менеджеры размещения
- •Элементы управления
- •Визуальные компоненты JavaBeans
- •Задания к главе 13 Вариант а
- •Вариант b
- •Жизненный цикл потока
- •Управление приоритетами и группы потоков
- •Управление потоками
- •Потоки-демоны
- •Потоки в графических приложениях
- •Методы synchronized
- •Инструкция synchronized
- •Состояния потока
- •Потоки в j2se 5
- •Задания к главе 14 Вариант а
- •Вариант b
- •Тестовые задания к главе 14
- •Вопрос 14.1.
- •Вопрос 14.2.
- •Вопрос 14.3.
- •Вопрос 14.4.
- •Вопрос 14.5.
- •Г лава 15 сетевые программы Поддержка Интернет
- •Сокетные соединения по протоколу tcp/ip
- •Многопоточность
- •Датаграммы и протокол udp
- •Задания к главе 15 Вариант а
- •Вариант b
- •Древовидная модель
- •Элементы таблицы стилей
- •Задания к главе 16 Вариант а
- •Тестовые задания к главе 16
- •Запуск контейнера сервлетов и размещение проекта
- •Первая jsp
- •Взаимодействие сервлета и jsp
- •Задания к главе 17 Вариант а
- •Вариант b
- •Интерфейс ServletContext
- •Интерфейс ServletConfig
- •Интерфейсы ServletRequest и HttpServletRequest
- •Интерфейсы ServletResponse и HttpServletResponse
- •Обработка запроса
- •Многопоточность
- •Электронная почта
- •Задания к главе 18 Вариант а
- •Вариант b
- •Стандартные элементы action
- •Неявные объекты
- •Демонстрация работы тегов c:forEach, c:choose, c:when, c:otherwise
- •Данная страница демонстрирует работу тегов
- •Включение ресурсов
- •Обработка ошибок
- •Технология взаимодействия jsp и сервлета
- •Задания к главе 19
- •Вариант а
- •Вариант b
- •Субд MySql
- •Простое соединение и простой запрос
- •Метаданные
- •Подготовленные запросы и хранимые процедуры
- •Транзакции
- •Id студента: 83, Petrov Внесены данные в students: 83, Petrov Внесены данные в course: 83, xml Данные внесены - транзакция завершена
- •Точки сохранения
- •Пул соединений
- •Задания к главе 20 Вариант а
- •Вариант b
- •Обработка событий
- •Фильтры
- •Задания к главе 21 Вариант а
- •Вариант b
- •Вопрос 21.5.
- •Вопрос 21.6.
- •Г лава22 пользовательские теги
- •Простой тег
- •Тег с атрибутами
- •Тег с телом
- •Элементы action
- •Задания к главе 22 Вариант а
- •Вариант b
- •П риложение 2
- •Включение скриптов на языке JavaScript в html-код
- •Отладка скриптов JavaScript
- •Типы данных
- •Специальные числа
- •Булев тип
- •Переменные типа Undefined и Null
- •Массивы
- •Операторы и выражения
- •Оператор with
- •Оператор switch
- •Метод eval()
- •Функции
- •Передача параметров по значению и по ссылке
- •Глобальные и локальные переменные
- •Пользовательские объекты
- •Прототипы
- •Встроенные объекты Array, Date, Math Объект Array
- •Объект Date
- •Объект Math
- •Объекты window и document
- •Создание новых узлов
- •Добавление новых узлов в документ
- •Удаление и замена узлов в документе
- •Использование каскадных таблиц стилей в dom
- •Свойство элемента innerHtml и outerHtml
- •Динамическое назначение событий
- •Ключевое слово this
- •П риложение3
- •Проектная модель
- •Uml как программный язык
- •Нотации и метамодель
- •Диаграммы, которые ниже будут рассмотрены с разной степенью детализации:
- •Свойства
- •Множественность
- •Операторы
- •П риложение 4 базы данных и язык sql
- •Реляционные субд Модель данных в реляционных субд
- •Нормализация модели данных
- •Язык sql
- •Команды sql
- •Команды определения структуры данных (DataDefinitionLanguage–ddl)
- •Команды манипулирования данными (Data Manipulation Language – dml)
- •Команды управления транзакциями (TransactionControlLanguage–tcl)
- •Команды управления доступом (DataControlLanguage–dcl)
- •Работа с командами sql
- •Ключевое слово distinct
- •Секция from, логическое связывание таблиц
- •Секция where
- •Секция orderby
- •Групповые функции
- •Секция group by
- •Секция having
- •Изменение данных
- •Команда insert
- •Команда delete
- •Команда update
- •Определение структуры данных Команда createtable
- •Команда droptable
- •П риложение5
- •П риложение 6
- •П риложение7 журнал сообщений (logger)
- •П риложение 8
- •Портлеты
Состояния потока
В классе Thread объявлено внутреннее перечисление State, простейшее применение элементов которого призвано помочь в отслеживании состояний потока в процессе функционирования приложения и, как следствие, в улучшении управления им.
/* пример # 11 : состояния NEW, RUNNABLE, TIMED_WAITING, TERMINATED : ThreadTimedWaitingStateTest.java */
package chapt14;
public class ThreadTimedWaitingStateTest extends Thread {
public void run() {
try {
Thread.sleep(50);
} catch (InterruptedException e) {
System.err.print("ошибка потока");
}
}
public static void main(String [] args){
try{
Thread thread = new ThreadTimedWaitingStateTest();
// NEW – поток создан, но ещё не запущен
System.out.println("1: " + thread.getState());
thread.start();
// RUNNABLE – поток запущен
System.out.println("2: " + thread.getState());
Thread.sleep(10);
// TIMED_WAITING
// поток ждет некоторое время окончания работы другого потока
System.out.println("3: " + thread.getState());
thread.join();
// TERMINATED – поток завершил выполнение
System.out.println("4: " + thread.getState());
} catch (InterruptedException e) {
System.err.print("ошибка потока");
}
}
}
В результате компиляции и запуска будет выведено:
1: NEW
2: RUNNABLE
3: TIMED_WAITING
4: TERMINATED
/* пример # 12 : состояния BLOCKED, WAITING : ThreadWaitingStateTest.java */
package chapt14;
public class ThreadWaitingStateTest extends Thread {
public void run() {
try {
synchronized (this) {
wait();
}
} catch (InterruptedException e) {
System.err.print("ошибка потока");
}
}
public static void main(String[] args) {
try {
Thread thread = new ThreadWaitingStateTest();
thread.start();
synchronized (thread) {
Thread.sleep(10);
// BLOCKED – because thread attempting to acquire a lock
System.out.println("1: " + thread.getState());
}
Thread.sleep(10);
// WAITING – метод wait() внутри synchronized
// останавил поток и освободил блокировку
System.out.println("2: " + thread.getState());
thread.interrupt();
} catch (InterruptedException e) {
System.err.print("ошибка потока");
}
}
}
В результате компиляции и запуска будет выведено:
1: BLOCKED
2: WAITING
Потоки в j2se 5
Java всегда предлагала широкие возможности для мультипрограммирования: потоки – это основа языка. Однако очень часто использование таких возможностей становилось ловушкой: правильно написать и отладить многопоточную программу достаточно сложно.
В версии 1.5 языка добавлены пакеты классов java.util.concurrent.locks, java.util.concurrent.atomic, java.util.concurrent, возможности которых обеспечивают более высокую производительность, масштабируемость, построение потокобезопасных блоков параллельных (concurrent) классов, вызов утилит синхронизации, использование семафоров, ключей и atomic-переменных.
Возможности синхронизации существовали и ранее. Практически это означало, что синхронизированные объекты блокировались, хотя необходимо это было далеко не всегда. Например, поток, изменяющий одну часть объекта Hashtable, блокировал работу других потоков, которые хотели прочесть (даже не изменить) совсем другую часть этого объекта. Поэтому введение дополнительных возможностей, связанных с синхронизаций потоков и блокировкой ресурсов довольно логично.
Ограниченно потокобезопасные (thread safe) коллекции и вспомогательные классы управления потоками сосредоточены в пакете java.util.concurrent. Среди них можно отметить:
параллельные классы очередей ArrayBlockingQueue (FIFO очередь с фиксированой длиной), PriorityBlockingQueue (очередь с приоритетом) и ConcurrentLinkedQueue (FIFO очередь с нефиксированой длиной);
параллельные аналоги существующих синхронизированых классов-коллекций ConcurrentHashMap (аналог Hashtable) и CopyOnWriteArrayList (реализация List, оптимизированная для случая, когда количество итераций во много раз превосходит количество вставок и удалений);
механизм управления заданиями, основанный на возможностях класса Executor, включающий пул потоков и службу их планирования;
высокопроизводительный класс Lock, поддерживающий ограниченные ожидания снятия блокировки, прерываемые попытки блокировки, очереди блокировки и установку ожидания снятия нескольких блокировок посредством класса Condition;
классы атомарных переменных (AtomicInteger, AtomicLong, AtomicReference), а также их высокопроизводительные аналоги SyncronizedInt и др.;
классы синхронизации общего назначения, такие как Semaphore, CountDownLatch (позволяет потоку ожидать завершения нескольких операций в других потоках), CyclicBarrier (позволяет нескольким потокам ожидать момента, когда они все достигнут какой-либо точки) и Exchanger (позволяет потокам синхронизироваться и обмениваться информацией);
обработка неотловленных прерываний: класс Thread теперь поддерживает установку обработчика на неотловленные прерывания (подобное ранее было доступно только в ThreadGroup).
Хорошим примером новых возможностей является синхронизация коллекции типа Hashtable. Объект Hashtable синхронизируется целиком, и если один поток занял кэш остальные потоки вынуждены ожидать освобождения объекта. В случае же использования нового класса ConcurrentHashMap практически все операции чтения могут проходить одновременно, операции чтения и записи практически не задерживают друг друга, и только одновременные попытки записи могут блокироваться. В случае же использования данного класса как кэша (спецификой которого является большое количество операций чтения и малое – записи), блокироваться многопоточный код практически не будет.
В таблице приведено время выполнения (в миллисекундах) программы, использовавшей в качестве кэша ConcurrentHashMap и Hashtable. Тесты проводились на двухпроцессорном сервере под управлением Linux. Количество данных для большего количества потоков увеличивалось.
Количество потоков |
ConcurrentHashMap |
Hashtable |
1 |
1.00 |
1.03 |
2 |
2.59 |
32.40 |
4 |
5.58 |
78.23 |
8 |
13.21 |
163.48 |
16 |
27.58 |
341.21 |
32 |
57.27 |
778.41 |
// пример # 13 : применение семафора: Sort.java : ArraySort.java
package chapt14;
import java.util.concurrent.*;
public class Sort {
public static final int ITEMS_COUNT = 15;
public static double items[];
// семафор, контролирующий разрешение на доступ к элементам массива
public static Semaphore sortSemaphore =
new Semaphore(0, true);
public static void main(String[] args) {
items = new double[ITEMS_COUNT];
for(int i = 0 ; i < items.length ; ++i)
items[i] = Math.random();
new Thread(new ArraySort(items)).start();
for(int i = 0 ; i < items.length ; ++i) {
/*
* при проверке доступности элемента сортируемого
* массива происходит блокировка главного потока
* до освобождения семафора
*/
sortSemaphore.acquireUninterruptibly();
System.out.println(items[i]);
}
}
}
class ArraySort implements Runnable {
private double items[];
public ArraySort(double items[]) {
this.items = items;
}
public void run(){
for(int i = 0 ; i < items.length - 1 ; ++i) {
for(int j = i + 1 ; j < items.length ; ++j) {
if( items[i] < items[j] ) {
double tmp = items[i];
items[i] = items[j];
items[j] = tmp;
}
}
// освобождение семафора
Sort.sortSemaphore.release();
try {
Thread.sleep(71);
} catch (InterruptedException e) {
System.err.print(e);
}
}
Sort.sortSemaphore.release();
}
}