No ano passado, vários projetos precisavam usar o JavaScript para travar, então escrevi alguns semelhantes, um dos quais:
Copie o código do código da seguinte forma:
// publicado por Indream Luo
// CONTAL: [email protected]
// versão: chinês 1.0.0
! Função ($) {
window.indream = window.indream || {};
$ .indream = Indream;
Indream.async = {
//
//Trancar
// bloqueio: o número da fechadura
// Ação: a maneira de executar após o desbloqueio
//
Lock: function (bloqueio, ação) {
$ .indream.async.waitings [Lock] = $ .indream.async.waitings [Lock] || [];
$ .indream.async.waitings [bloqueio] .push (ação);
// Se o bloqueio não for usado, a ação atual bloqueia a trava
if (! $. Indream.async.lockstatus [Lock] && Action) {
$ .indream.async.lockstatus [bloqueio] = true;
if (argumentos.Length> 2) {{
var args = 'argumentos [2]';
for (var i = 3; i <argumentos.length; i ++) {
args + = ', argumentos [' + i + ']';
}
Eval ('$. Indream.async.action.call (ação,' + args + ')');
} Outro {
$ .indream.async.action.call (ação);
}
}
},
//
// desbloqueio
// bloqueio: o número da fechadura
//
RELEASELOCK: function (bloqueio) {
$ .indream.async.waitings [bloqueio] .shift ();
// Se a fila de espera for objeto, a fila de espera será executada, caso contrário, desbloqueie
if ($ .indream.async.waitings [bloqueio] .Length) {
$ .indream.async.waitings [bloqueio] [0] ();
} Outro {
$ .indream.async.lockstatus [bloqueio] = false;
}
},
//
// status de bloqueio
//
LOCKSTATUS: [],
//
// esperando o evento concluir
// bloqueio: codificação de bloqueio, a mesma codificação será integrada a uma sequência, desencadeando
//
Espere: function (bloqueio, ação) {
$ .indream.async.waitings [código] = $ .indream.async.waitings [código] || [];
$ .indream.async.waitings [código] .push (ação);
},
//
// esperando a sequência
//
espera: [],
//
// cache de dados
//
AÇÃO: {
//
// Métodos relacionados para monitoramento e retorno de chamada
//
ligar de volta: {
//
//monitor
//
Ouça: function (ActionName, chamada de retorno) {
var lista = $ .indream.async.action.calllback.list;
List [ACTIONNAME] = LIST [ACTIONNAME] || [];
List [ActionName] .push (retorno de chamada);
},
//
//
//
Call: function (actionName, args) {
var lista = $ .indream.async.action.calllback.list;
if (list [ActionName] && List [ActionName] .Length) {
para (var i na lista [actionName]) {
$ .indream.async.action.call (list [ActivityName] [i], args);
}
}
},
//
// A lista de retorno de chamada existente
//
Lista: []
},
//
// se o método existe e se o parâmetro existe para escolher o método de execução apropriado
//
Call: function (ação) {
if (ação) {
if (argumentos.Length> 1) {{
var args = 'argumentos [1]';
for (var i = 2; i <argumentos.length; i ++) {
args + = ', argumentos [' + i + ']';
}
Eval ('Action (' + args + ')');
} Outro {
Ação ();
}
}
}
}
}
} (window.jQuery);
Vários elementos de bloqueio mútuo são:
• Bloquear e desbloquear
• Esperando pela fila
• Método de execução
Uso dos bloqueios acima:
Copie o código do código da seguinte forma:
// Defina o nome da fechadura
var Lock = 'scrolltop ()';
// Use o bloqueio
$ .indream.async.lock (Lock, function () {{) {
var scrolltop = $ (janela).
Var Timer;
varrfLTime = 100;
for (timer = 0; timer <= tempo integral; timer += 10) {
setTimeout ('$ (janela). scrolltop (' + (scrolltop * (tempo integral -timer) / tempo integral) + ');', timer);
}
// Libere o bloqueio
setTimeout ('$. Indream.async.releaselock ("' + bloqueio + '");', tempo integral);
});
Em relação à realização desse tempo, explique brevemente.
-A quantidade de bloqueio de spin ou sinal
O JavaScript não possui função de bloqueio, portanto os bloqueios são implementados em altos níveis.
De acordo com o princípio do JavaScript Single -Thread, os recursos do thread da JS são muito limitados e não são adequados para o uso de bloqueios de spin, então escolhi usar o semáforo.
A trava auto -spin é aproximadamente assim, é claro, é mais útil:
Copie o código do código da seguinte forma:
While (true) {
// Faça algo ...
}
Infelizmente, isso deve aproveitar o encadeamento completo. Obviamente, se necessário, você pode escolher a combinação de SetInterval e ClearInterval para alcançá -lo, e o efeito será bom.
O método da quantidade de sinal é simples aqui e o princípio é simples, tão curto quanto o código. A ordem do trabalho é aproximadamente:
• Empurre o segmento de código (a ação de retorno de chamada) para a fila de espera
• Determine se o bloqueio atual é mantido.
• Quando a trava é liberada, o próximo ajuste é passado na fila de espera e a fechadura é passada e executada
-A liberação automática ou liberação manual
A maneira mais confortável é, é claro, é lançada automaticamente quando o programa atual é executado, mas isso não é fácil, porque mais situações precisam personalizar o lançamento da cena.
O que é usado por si só é o método assíncrono; portanto, outros conteúdos assíncronos geralmente aparecem, como Ajax e animação jQuery. Nesse momento, a liberação automática não atende à demanda, porque, de fato, a verdadeira "execução" é que, após o retorno de chamada assíncrono dentro dela, ou seja, basicamente, apenas os desenvolvedores podem se entender, então eles optam por lançá -lo aqui.
No entanto, ainda existem defeitos, ou seja, liberação repetida.
Pode -se observar que todos os objetos de bloqueio são públicos ou que todos os objetos do JS são públicos, a menos que a variável local seja isolada no nível de acesso. No entanto, o "travamento" em si é um recurso público, portanto não há como lidar com isso.
A otimização que pode ser feita aqui deve ser fechada com um nome de bloqueio público como setInterval e ClearInterval, e o desbloqueio com IDs de bloqueio privado podem impedir a liberação repetida. No entanto, não há no código antigo acima, estima -se que ele seja usado em breve.