Язык JAVA. Потоки

Язык JAVA. Апплеты. Включение апплетов на HTML страницу.

http://www.helloworld.ru/texts/comp/lang/java/java/15.htm

Апплеты — это маленькие приложения, которые размещаются на серверах Internet, транспортируются клиенту по сети, автоматически устанавливаются и запускаются на месте, как часть документа HTML. Когда апплет прибывает к клиенту, его доступ к ресурсам ограничен.

Ниже приведен исходный код канонической программы HelloWorld, оформленной в виде апплета:

import java.awt.*;
import java.applet.*;
public class HelloWorldApplet extends Applet {
public void paint(Graphics g) {
g.drawString("Hello World!", 20, 20);
} }

Для запуска этого апплета в браузере необходим следующий HTML-код:

<applet code="HelloWorldApplet" width=200 height=40>
</applet>

Вы можете поместить эти строки в отдельный html-файл (HelloWorldApplet.html), либо вставить их в текст этой программы в виде комментария и запустить программу appletviewer с его исходным текстом в качестве аргумента.

Тег HTML <Applet>

Тег <applet> используется для запуска апплета как из HTML-документа, так и из программы appletviewer. Программа appletviewer выполняет каждый найденный ей тег <applet> в отдельном окне, в то время как браузеры позволяют разместить на одной странице несколько апплетов. Синтаксис тэга <APPLET> в настоящее время таков:

<APPLET

CODE = appletFile
OBJECT = appletSerialFile
WIDTH = pixels
HEIGHT = pixels
[ARCHIVE = jarFiles]
[CODEBASE = codebaseURL]
[ALT = alternateText]
[NAME = appletInstanceName]
[ALIGN = alignment]
[VSPACE = pixels]
[HSPACE = pixels]
>
[< PARAM NAME = AttributeNamel VALUE = AttributeValuel >]
[< PARAM NAME = AttributeName2 VALUE = AttributeValue2 >]
[HTML-текст, отображаемый при отсутствии поддержки Java]
</APPLET>

Передача параметров: <applet code=Testing width=40 height=40> <param name=fontName value=Univers> <param name=fontSize value=14> <param name=leading value=2> <param name=accountEnabled value=true>

Извлечение параметров: String FontName = getParameter("fontName"); String FontSize = Integer.parseInt(getParameter("fontSize")); String Leading = Float.valueOf(getParameter("leading")); String PaidUp = Boolean.valueOf(getParameter("accountEnabled"));

http://java.sun.com/javase/6/docs/api/java/lang/Thread.html

http://www.freejavaguide.com/java-threads-tutorial.pdf

class PrimeThread extends Thread { long minPrime; PrimeThread(long minPrime) { this.minPrime = minPrime; } public void run() { //compute primes larger than minPrime... }}   PrimeThread p = new PrimeThread(143);p.start();

class PrimeRun implements Runnable { long minPrime; PrimeRun(long minPrime) { this.minPrime = minPrime; } public void run() { //compute primes larger than minPrime... }}   PrimeRun p = new PrimeRun(143);new Thread(p).start();

The Java language provides two keywords for ensuring that data can be shared between threads in a controlled manner: synchronized and volatile.

Synchronized has two important meanings: it ensures that only one thread executes a protected section of code at one time (mutual exclusion or mutex), and it ensures that data changed by one thread is visible to other threads (visibility of changes).

Without synchronization, it is easy for data to be left in an inconsistent state. Synchronization allows to define blocks of code that must run atomically, in which they appear to execute in an all-or-nothing manner, as far as other threads can tell.

It is possible for two threads executing on two different processors to see two different values for the same variable! (if a memory location is modified in the cache on one processor, it is not necessarily visible to other processors until the writer's cache is flushed and the reader's cache is invalidated)

Volatile is simpler than synchronization and is suitable only for controlling access to single instances of primitive variables -- integers, booleans, and so on. When a variable is declared volatile, any write to that variable will go directly to main memory, bypassing the cache, while any read of that variable will come directly from main memory, bypassing the cache. This means that all threads see the same value for a volatile variable at all times.

The Object class defines the methods wait(), notify(), and notifyAll(). To execute any of these methods, you must be holding the lock for the associated object.

Wait() causes the calling thread to sleep until it is interrupted with Thread.interrupt(), the specified timeout elapses, or another thread wakes it up with notify() or notifyAll().

When notify() is invoked on an object, if there are any threads waiting on that object via wait(), then one thread will be awakened. When notifyAll() is invoked on an object, all threads waiting on that object will be awakened.

public class SyncExample { private static lockObject = new Object(); private static class Thread1 extends Thread { public void run() { synchronized (lockObject) { x = y = 0; System.out.println(x); } } } private static class Thread2 extends Thread { public void run() { synchronized (lockObject) { x = y = 1; System.out.println(y); } } } public static void main(String[] args) { new Thread1().run(); new Thread2().run(); } }

The simplest way to create a synchronized block is to declare a method as synchronized. This means that before entering the method body, the caller must acquire a lock: public class Point { public synchronized void setXY(int x, int y) { this.x = x; this.y = y; } } For ordinary synchronized methods, this lock will be the object on which the method is being invoked. For static synchronized methods, this lock will be the monitor associated with the Class object in which the method is declared. Just because setXY() is declared as synchronized doesn't mean that two different threads can't still execute setXY() at the same time, as long as they are invoking setXY() on different Point instances. Only one thread can execute setXY(), or any other synchronized method of Point, on a single Point instance at one time.

Дата добавления: 2015-01-03