(1) multi-threading: una aplicación son múltiples rutas de ejecución
Proceso: la aplicación se está ejecutando. El programa se está ejecutando, la asignación de recursos del sistema y llamadas unidades independientes. Cada proceso tiene su propio espacio de memoria y recursos del sistema.
Tema: medios de ejecución para ejecutar el recorrido de proceso (en un solo flujo de proceso secuencial de control es una ruta de ejecución)
Single-roscado: Una aplicación tiene único camino una ejecución
Multihilo: una aplicación son múltiples rutas de ejecución
Significado multi-proceso?
Mejorar la utilización de la CPU
Significado múltiples hilos?
Aumento del uso de aplicaciones
Paralelo y concurrente:
Lógicamente es paralela al mismo tiempo, medios para ejecutar simultáneamente dentro de un cierto tiempo de una pluralidad de programas.
Concurrencia es a la vez físicamente significa una pluralidad de programas para ejecutar simultáneamente en un cierto punto de tiempo.
principio (2) programa Java operativo e iniciar la JVM es hacer multiproceso?
R: Empiece por el comando java JVM, JVM se inicia el equivalente de iniciar un proceso. Luego está el proceso crea un hilo principal para llamar al método principal.
B: JVM inicio es multi-hilo, porque el hilo de recolección de basura también se inició por primera vez, aparecerá fácilmente de la memoria. Ahora hebra de recogida de basura juntos delante del hilo principal,
inicia mínimo dos hilos, por lo que, al inicio de la JVM, de hecho, ser multi-hilo.
(3) multi-hilo implementaciones (master)
A: la herencia de clases Tema
1. Paso:
R: clases personalizadas MyThread heredan la clase Thread.
B: clase MyThread que se ejecutan de anulación ()
¿Por qué método run ()?
Todo el código no está en la necesidad de clases a ser un hilo de ejecución. Y esta vez, con el fin de ser capaz de distinguir lo que es un hilo de ejecución de código, Java proporciona una clase Thread
ejecutar () para los que contienen un hilo de código de ejecución
C: crear objetos MyThread my1 = new MyThread ();
D: iniciar un my1.start hilo ();
nota:
1. La diferencia entre el run () y start () están?
run (): los paquetes de código son simplemente un hilo de ejecución, una llamada directa es un método común
start (): En primer lugar se inicia el hilo, y luego llamar a la JVM para ejecutar este hilo () método.
2.my1.start (); my1.start (); IllegalThreadStateException: estado anormal hilo Ilegal
Debido a que este es el equivalente de mi hilo se llama dos veces. En lugar de dos roscas de entrada.
2. Obtener el nombre del método / set el hilo:
pública final Cadena getName (): Obtener el nombre del hilo.
Establecer el nombre de la rosca: public void setName final (String name)
Tema currentThread static (): Devuelve el objeto hilo que se está ejecutando
Thread.currentThread (). GetName ()
B: aplicar Ejecutable
pasos:
A: clase personalizada MyRunnable implementar Ejecutable
B: override método run ()
C: Crear una clase de objetos MyRunnable
D: Crear objetos de clase Thread, y el objeto C como la etapa de transferencia del parámetro de configuración
(4) problemas de programación hilo y prioritarios
A: programación de subprocesos
R: programación de tiempo compartido
b: programación preventivo (Java se utiliza en el modo de programación)
B: Obtener y establecer la prioridad de subprocesos
pública final getPriority int (): Devuelve la prioridad del objeto hilo
pública final setPriority vacío (int newPriority): Modificación de la prioridad hilo.
prioridad por defecto hilo es de 5.
Rango de prioridad hilo es: 1-10.
prioridad alta densidad de hilos sólo indica una alta probabilidad de rosca obtiene el tiempo de CPU rebanada, pero más que el número de veces, o cuando se ejecutan varias veces para ver mejores resultados.
IllegalArgumentException: excepción argumento ilegal. Lanzado para indicar que pasa un parámetro ilegal o incorrecta al método.
Control (5) hilos (método común)
A: hilo dormir
public static void sueño (tiempo millis)
B: Hilo de la adición
vacío public final join (): Espera a este hilo.
C: Hilo de cortesía
pública rendimiento static void (): pausar el objeto hilo está ejecutando actualmente, y realizar otras roscas. Vamos a ejecutar múltiples hilos de un más armoniosa, pero no puede ser invocado para garantizar que una persona una vez.
D: subproceso de fondo
setDaemon vacío public final (Booleano): este tema se marca como un hilo de utilidad o una hebra de usuario.
Cuando se ejecuta hilo es un hilo de utilidad, Java salida de la máquina virtual. Este método debe ser llamado antes de iniciar el hilo.
E: terminar la hebra (maestro)
público parada final void (): hilo de parada, fuera de fecha, pero también puede ser utilizado.
interrupción public void (): Hilo de interrupción. El estado de la rosca para terminar, y lanzar un InterruptedException.
(6) el ciclo de vida de la rosca
A: Nueva
B: Listo
C: Ejecutar
D: bloqueado
E: Muerte
El diagrama de transición de estado del hilo y la aplicación común:
Implementar programa de boletos (7) Cine
A: la herencia de clases Tema
public class SellTicket extends Thread {
// 定义100张票
// private int tickets = 100;
// 为了让多个线程对象共享这100张票，我们其实应该用静态修饰
private static int tickets = 100;
@Override
public void run() {
// 定义100张票
// 每个线程进来都会走这里，这样的话，每个线程对象相当于买的是自己的那100张票，这不合理，所以应该定义到外面
// int tickets = 100;
// 是为了模拟一直有票
while (true) {
if (tickets > 0) {
System.out.println(getName() + "正在出售第" + (tickets--) + "张票");
}
}
}
}
/*
* 某电影院目前正在上映贺岁大片(红高粱,少林寺传奇藏经阁)，共有100张票，而它有3个售票窗口售票，请设计一个程序模拟该电影院售票。
* 继承Thread类来实现。
*/
public class SellTicketDemo {
public static void main(String[] args) {
// 创建三个线程对象
SellTicket st1 = new SellTicket();
SellTicket st2 = new SellTicket();
SellTicket st3 = new SellTicket();
// 给线程对象起名字
st1.setName("窗口1");
st2.setName("窗口2");
st3.setName("窗口3");
// 启动线程
st1.start();
st2.start();
st3.start();
}
}B: aplicar Ejecutable
public class SellTicket implements Runnable {
// 定义100张票
private int tickets = 100;
@Override
public void run() {
while (true) {
if (tickets > 0) {
System.out.println(Thread.currentThread().getName() + "正在出售第"
+ (tickets--) + "张票");
}
}
}
}
/*
* 实现Runnable接口的方式实现
*/
public class SellTicketDemo {
public static void main(String[] args) {
// 创建资源对象
SellTicket st = new SellTicket();
// 创建三个线程对象
Thread t1 = new Thread(st, "窗口1");
Thread t2 = new Thread(st, "窗口2");
Thread t3 = new Thread(st, "窗口3");
// 启动线程
t1.start();
t2.start();
t3.start();
}
}
(8) cine billetaje problemas de programas
R: Con el fin de responder mejor a la escena real, se unió al sueño de 100 milisegundos.
B: emisión del billete
R: El mismo billete varias veces
B: votos negativos
public class SellTicket implements Runnable {
// 定义100张票
private int tickets = 100;
@Override
public void run() {
while (true) {
// t1,t2,t3三个线程
// 这一次的tickets = 1;
if (tickets > 0) {
// 为了模拟更真实的场景，我们稍作休息
try {
Thread.sleep(100); //t1进来了并休息，t2进来了并休息，t3进来了并休息，
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName() + "正在出售第"
+ (tickets--) + "张票");
//窗口1正在出售第1张票,tickets=0
//窗口2正在出售第0张票,tickets=-1
//窗口3正在出售第-1张票,tickets=-2
}
}
}
}
/*
* 实现Runnable接口的方式实现
*
* 通过加入延迟后，就产生了连个问题：
* A:相同的票卖了多次
* CPU的一次操作必须是原子性的
* B:出现了负数票
* 随机性和延迟导致的
*/
public class SellTicketDemo {
public static void main(String[] args) {
// 创建资源对象
SellTicket st = new SellTicket();
// 创建三个线程对象
Thread t1 = new Thread(st, "窗口1");
Thread t2 = new Thread(st, "窗口2");
Thread t3 = new Thread(st, "窗口3");
// 启动线程
t1.start();
t2.start();
t3.start();
}
}
(9) La razón por cuestiones de seguridad de múltiples hilos (que más tarde determinar es si existe un programa basado en los temas de seguridad de rosca)
R: Ya sea entorno de multiproceso
B: ¿Hay un dato compartido
C: ¿Hay intercambio de datos cuenta de resultados múltiples
(10) síncrono de resolver los problemas de seguridad hilo
Los múltiples códigos declaraciones a la operación del paquete de datos compartidos en su conjunto, de manera que cuando, otros no se puede realizar un hilo de ejecución.
A: bloques de código de sincronización
sincronizado (objeto) {
Se requiere código de sincronización;
}
de aquí objeto de bloqueo puede ser cualquier objeto.
Tiempo para prestar atención a resolver el problema: múltiples hilos deben ser la misma cerradura.
B: método de sincronización
El método de sincronización se aplica sobre.
Aquí está este objeto de bloqueo
C: método sincronizado estático
El método de sincronización se aplica sobre.
Aquí el objeto de bloqueo es un objeto de archivo de código de bytes de clases actual (reflexión)
La sincronización de los beneficios
Parece solución de sincronización a los problemas de seguridad de múltiples hilos.
La sincronización de negligencia
1. Cuando el hilo es un tiempo bastante largo, ya que cada hilo de bloqueo de sincronización al juez, se trata de una gran cantidad de recursos, reduciría efectivamente la eficacia del programa. (Ineficiente)
2. propensos a un punto muerto
public class SellTicket implements Runnable {
// 定义100张票
private int tickets = 100;
// 定义同一把锁
private Object obj = new Object();
@Override
public void run() {
while (true) {
// t1,t2,t3都能走到这里
// 假设t1抢到CPU的执行权，t1就要进来
// 假设t2抢到CPU的执行权，t2就要进来,发现门是关着的，进不去。所以就等着。
// 门(开,关)
synchronized (obj) { // 发现这里的代码将来是会被锁上的，所以t1进来后，就锁了。(关)
if (tickets > 0) {
try {
Thread.sleep(100); // t1就睡眠了
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName()
+ "正在出售第" + (tickets--) + "张票 ");
//窗口1正在出售第100张票
}
} //t1就出来可，然后就开门。(开)
}
}
}
public class SellTicketDemo {
public static void main(String[] args) {
// 创建资源对象
SellTicket st = new SellTicket();
// 创建三个线程对象
Thread t1 = new Thread(st, "窗口1");
Thread t2 = new Thread(st, "窗口2");
Thread t3 = new Thread(st, "窗口3");
// 启动线程
t1.start();
t2.start();
t3.start();
}
}
(11) Recordando la clase thread-safe anterior
R: StringBuffer
B: Vector
C: Hashtable
D: cómo poner un hilo de seguridad clases de colección en unas clases de colección seguras para subprocesos
Las colecciones pueden ser un método de herramientas.
// 线程安全的类
StringBuffer sb = new StringBuffer();
Vector<String> v = new Vector<String>();
Hashtable<String, String> h = new Hashtable<String, String>();
// Vector是线程安全的时候才去考虑使用的，但是我还说过即使要安全，我也不用你
// 那么到底用谁呢?
// public static <T> List<T> synchronizedList(List<T> list)
List<String> list1 = new ArrayList<String>();// 线程不安全
List<String> list2 = Collections
.synchronizedList(new ArrayList<String>()); // 线程安全
