1, de bloqueio e uma visão geral de bloqueio do uso de
um, Resumo: Enquanto podemos compreender o problema do bloco de código de bloqueio de sincronização objeto e método de sincronização, mas não vemos diretamente onde adicionar uma fechadura, onde o bloqueio será liberado, a fim de forma mais clara a expressão de como bloqueio e libertar o fecho, mais tarde jdk1.5 proporcionar uma nova fechadura objeto de bloqueio
b, bloqueio e ReentrantLock
- ReentrantLock: a exclusão mútua de reentrada Lock, tendo um monitor implícita bloqueio utilizando métodos e declarações sincronizados acessado o mesmo comportamento e semântica básica, mas mais poderoso.
- Lock: implementações fornecem mais extenso de bloqueio disponíveis do que os métodos sincronizados e operação de declarações. Esta implementação permite uma estrutura mais flexível, podem ter propriedades muito diferentes, pode suportar múltiplos condição associada objetos.
c, de bloqueio bloqueia 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, uma visão geral do problema de impasse e usar
, um Resumo: Quando uma sincronização aninhados, pode facilmente causar problema de impasse, cada um refere-se a um dois ou mais threads na implementação do processo, devido à competição por recursos gerados esperando o fenômeno.
Impasse: dois ou mais threads na hora de aproveitar a execução da CPU de, estão em um estado de espera
b, apresentações 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 o mecanismo de despertar entre os tópicos
uma vez a espera, devemos liberar imediatamente o bloqueio, em seguida, foi negociado o próximo despertar, acordar de onde de onde se pode esperar.
- espera void (); // chamar este objeto antes em outros tópicos notificar método () ou a notifyAll () método faz com que o segmento atual para esperar.
- espera void (longo tempo de espera); // chamar este objeto antes em outros tópicos notificar () o método notifyAll () método ou, ou um determinado período de tempo, levando a atual segmento para esperar.
- vazio notificar (); // acordar um único segmento de espera no monitor deste objeto.
- notifyAll void (); // acordar todos os segmentos de espera no monitor deste objeto.
a diferença entre o sono eo método método de espera: é possível fazer um thread está bloqueado
sleep () deve ser passado na quantidade de tempo, o tempo de espera pode passar ou não passar a quantidade de tempo a quantidade de
sono () após o thread para dormir, não liberar o bloqueio; wait () método uma vez temos de aguardar a liberação do bloqueio
4, diagramas de transição de estado e o fio comum da implementação do
novo: o fio é criado
pronto: a execução qualificada do CPU, mas a CPU não tem poderes executivos
para executar: a CPU é elegível para realizar, também tem uma execução CPU direito
obstrução: CPU não tem as qualificações para executar, nem tem o poder executivo da CPU
morte: CPU não tem as qualificações para executar, nem tem o poder executivo da CPU
5, e uma visão geral do uso do fio piscina
um, Overview: um recipiente, dentro pré-carregado objeto segmento, e gestão eficiente pode ajudar-nos a enfiar objeto, crie manualmente o nosso próprio segmento, é o recurso subjacente consumindo, e depois de o fio usado para cima, a morte, e não pode ser reutilizado, depois jdk1.5 deu oferecemos uma piscina boa fio, só precisa enviar a tarefa para o interior pool de threads.
-
Obtém o objeto de pool de threads, Java fornece-nos com uma fábrica, com a classe de fábrica para chegar aos objetos conjunto de encadeamentos
-
ExecutorService ExecutorService = Executors.newCachedThreadPool ();
-
JDK5 acrescentou classe de fábrica Executores para gerar um pool de threads, existem vários métodos como segue
-
public static ExecutorService newCachedThreadPool (); para criar uma série de tópicos na tarefa correspondente ao número de
-
public static ExecutorService newFixedThreadPool (nThreads int); fixo inicialização alguns tópicos
-
public static ExecutorService newSingleThreadExecutor (); inicializar um thread do pool
b, por exemplo:
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, anônimo forma classe interna para alcançar programas multi-threaded
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, um temporizador e uma visão geral do uso de
um, Overview: Timer é um muito ampla aplicação de ferramentas de rosqueamento, pode ser usado para a futura programação múltiplas tarefas temporais realizado em uma discussão de fundo maneira. Em Java, a definição de uma agenda pode ser implementada pela função de temporizador e TimerTask classes.
b, temporizador e TimerTask
- O Timer:
pública do Timer () // criar um novo temporizador
cronograma public void (tarefa TimerTask, longo atraso); // Agenda a tarefa especificada após um atraso especificado
cronograma public void (tarefa TimerTask, longo atraso, longo período); / / Agenda a tarefa especificada a partir do início após um atraso especificado para execução repetida-delay fixo.
cronograma public void (tarefa TimerTask, Data tempo); // programado para executar tarefas específicas em um determinado momento.
cronograma public void (tarefa TimerTask, Data firstTime, longo período); // agendamento da tarefa especificado repetido na hora especificada uma execução atraso fixo. - TimerTask
RUN vazio abstrato pública (); // operação a ser realizada por esta tarefa timer.
boolean públicas cancelar (); // Cancela esta tarefa timer.
c, apresentações 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(); //关闭定时器
}
}
