1, bloqueo y una visión general de bloqueo de la utilización de
una, Información general: Si bien podemos entender el problema del bloque de código objeto de bloqueo de sincronización y método de sincronización, pero no vemos directamente en añadir una cerradura, donde se libera el bloqueo, con el fin de mayor claridad la expresión de la forma de bloqueo y liberar el bloqueo, JDK1.5 después proporcionar un nuevo objeto cerradura de bloqueo
b, bloqueo y ReentrantLock
- ReentrantLock: un mutex de reentrada de bloqueo, que tiene un monitor implícita bloqueo utilizando métodos y declaraciones sincronizados accede a la misma conducta y la semántica básica, pero más potente.
- Bloqueo: implementaciones proporcionan más extensa de bloqueo disponibles que los métodos sincronizados y operación de declaraciones. Esta implementación permite una estructura más flexible, puede tener propiedades muy diferentes, puede soportar múltiples objetos condición asociada.
c, Bloquear bloquea el uso
public class MyThread implements Runnable {
private static int tickets = 100 ; // 定义票数
private static final Lock lock = new ReentrantLock() ; // 创建Lock锁对象
@Override
public void run() {
while(true){
lock.lock() ; // 添加锁
if(tickets > 0){
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName() + "正在出售" + (tickets--) + "张票");
}
lock.unlock() ; // 释放锁
}
}
}
public class MyThreadDemo {
public static void main(String[] args) {
// 创建MyThread类的对象
MyThread mt = new MyThread() ;
// 创建3个线程对象
Thread t1 = new Thread(mt , "窗口1") ;
Thread t2 = new Thread(mt , "窗口2") ;
Thread t3 = new Thread(mt , "窗口3") ;
// 启动线程
t1.start() ;
t2.start() ;
t3.start() ;
}
}
2, una visión general del problema de interbloqueo y utilizar
una, Información general: Cuando una sincronización anidada, puede fácilmente causa problema de interbloqueo, cada uno se refiere a una de dos o más hilos en la implementación del proceso, debido a la competencia por los recursos generada esperando a que el fenómeno.
Punto muerto: dos o más hilos en el momento de aprovechar la ejecución de la CPU, están en un estado de espera
b, presentaciones de casos
class ObjectUtils {
//定义两把锁
public static final Object objA=new Object();
public static final Object objB = new Object();
}
class MyThread extends Thread {
boolean flag;
public MyThread(boolean flag) {
this.flag = flag;
}
@Override
public void run() {
if (flag) {
synchronized (ObjectUtils.objA) {
System.out.println("true 进来了 持有objA");
try {
sleep(10);
} catch (InterruptedException e) {
e.printStackTrace();
}
//阻塞
synchronized (ObjectUtils.objB) {
System.out.println("true 进来了 持有objB");
}
}
} else {
synchronized (ObjectUtils.objB) {
System.out.println("false 进来了 持有objB");
//阻塞
synchronized (ObjectUtils.objA) {
System.out.println("false 进来了 持有objA");
}
}
}
}
}
public class MyDemo {
public static void main(String[] args) throws InterruptedException {
MyThread th1 = new MyThread(true);
MyThread th2 = new MyThread(false);
th1.start();
th2.start();
}
}
输出结果：true 进来了 持有objA
false 进来了 持有objB
原因：在执行了第一条程序后，相互持有了对方的锁而未释放，导致程序发生阻塞不能往下执行
3, espera para el mecanismo de alerta entre los hilos
una vez que la espera, hay que soltar inmediatamente al bloqueo, a continuación, se cambió la siguiente despertador, despierta desde donde a partir de dónde esperar.
- espera nula (); // llamar a este objeto antes de notificar a otros hilos método () o la notifyAll () método hace que el subproceso actual que esperar.
- espera void (largo tiempo de espera); // llamar a este objeto antes en otros hilos notificar () el método notifyAll () método o, o una cantidad especificada de tiempo, dando lugar a la rosca actual a esperar.
- vacío Notify (); // despertar a un solo hilo de espera en el monitor de este objeto.
- notifyAll vacío (); // despertar todos los hilos esperando en el monitor de este objeto.
la diferencia entre el sueño y el método método de espera: es posible hacer que un hilo se bloquea
el sueño () debe ser aprobada en la cantidad de tiempo, el tiempo de espera puede pasar o no pasar a la cantidad de tiempo que la cantidad de
sueño () después de que el hilo para dormir, no liberar el bloqueo; método wait () una vez hay que esperar a la salida de la cerradura
4, diagramas de transición de estado y el hilo conductor de la aplicación de
la nueva: el hilo se ha creado
listas: una ejecución calificado de la CPU, pero la CPU no tiene poderes ejecutivos
para ejecutar: una CPU es elegible para llevar a cabo, también tiene una ejecución de CPU derecho
obstrucción: CPU no reunir los requisitos para llevar a cabo, ni tiene el poder ejecutivo de la CPU de
la muerte: CPU no tienen las calificaciones para llevar a cabo, ni tiene el poder ejecutivo de la CPU
5, y una visión general del uso de la agrupación de hebras
de una, Información general: un recipiente, en el interior precargado objeto hilo, y la gestión eficiente puede ayudarnos a hilo de objeto, crear manualmente nuestro propio hilo, es el recurso subyacente que consume, y después de que el hilo utilizado, la muerte, y no se puede volver a utilizar, después de JDK1.5 ha dado ofrecemos un grupo de subprocesos bien, sólo tenemos que enviar la tarea al interior del grupo de subprocesos.
-
Obtiene el objeto de grupo de subprocesos, Java nos proporciona una fábrica, con la clase de fábrica para llegar a los objetos grupo de subprocesos
-
ExecutorService ExecutorService = Executors.newCachedThreadPool ();
-
JDK5 añadió clase de fábrica Ejecutores para generar un grupo de subprocesos, hay varios métodos de la siguiente
-
public static ExecutorService newCachedThreadPool (); crear un número de hilos en la tarea correspondiente al número de
-
public static ExecutorService newFixedThreadPool (nThreads int); fija la inicialización pocos hilos
-
public static ExecutorService newSingleThreadExecutor (); inicializar un subproceso del grupo de subprocesos
b, por ejemplo:
public class MyDemo {
public static void main(String[] args) {
//获取线程池对象
ExecutorService executorService = Executors.newCachedThreadPool();
//往线程池中提交任务
MyRuannable myRuannable = new MyRuannable();
MyRuannable myRuannable2 = new MyRuannable();
MyRuannable myRuannable3 = new MyRuannable();
MyRuannable myRuannable4 = new MyRuannable();
executorService.submit(myRuannable);
executorService.submit(myRuannable2);
executorService.submit(myRuannable3);
executorService.submit(myRuannable4);
//关掉线程池
executorService.shutdown();
}
}
class MyRuannable implements Runnable{
@Override
public void run() {
System.out.println(Thread.currentThread().getName()+"任务执行了");
}
}
6, manera de clase interna anónima para lograr programas multi-roscados
public class MyDemo3 {
public static void main(String[] args) {
//匿名内部类来创建线程
//方式1
new Thread() {
@Override
public void run() {
System.out.println("线程执行了");
}
}.start();
//方式2：
Runnable runnable = new Runnable() {
@Override
public void run() {
System.out.println("线程执行了");
}
};
new Thread(runnable) {
}.start();
}
}
7, un temporizador y una visión general del uso de
una, Información general: Timer es una aplicación muy amplia de herramientas de roscado, se puede utilizar para la futura programación de múltiples tareas de sincronización realizan en un subproceso de fondo manera. En Java, la definición de un calendario puede ser implementado por el temporizador y TimerTask clases de funciones.
b, temporizador y TimerTask
- El Temporizador:
pública del temporizador () // crear un nuevo temporizador
horario public void (tarea TimerTask, mucho retraso); // programa la tarea especificada después de un retardo especificado
pública horario de vacío (tarea TimerTask, larga demora, a largo plazo); / / programa la tarea especificada desde el principio después de un retardo especificado para la ejecución de retardo fijo repetida.
horario public void (tarea TimerTask, Fecha del tiempo); // programado para realizar tareas específicas en un momento determinado.
horario public void (tarea TimerTask, Fecha firstTime, a largo plazo); // la programación de la tarea especificada repetida en el tiempo especificado una ejecución de retardo fijo. - TimerTask
RUN public abstract void (); // operación a realizar esta tarea por temporizador.
booleano públicas cancelan (); // Cancela esta tarea temporizador.
c, presentaciones de casos
定时任务的多次执行代码体现
定时删除指定的带内容目录
public class MyDemo {
public static void main(String[] args) throws ParseException {
Timer timer = new Timer();//创建定时器
MyTimerTask task = new MyTimerTask(timer);
//timer.schedule(task,2000); //参数1 定时任务，参数 等待多少毫秒后执行
// timer.schedule(task,2000,1000);//连环爆炸
task.cancel(); 取消定时任务
//指定日期去执行任务
String dateStr="2019-01-20 13:46:00";
Date date = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").parse(dateStr);
// timer.schedule(task,date,1000*60*60*24*30);
}
}
class MyTimerTask extends TimerTask{
Timer timer;
public MyTimerTask(Timer timer) {
this.timer=timer;
}
@Override
public void run() {
// System.out.println("砰~~~爆炸了");
// timer.cancel(); //关闭定时器
}
}
