Como começar rapidamente com VUE3.0: Entre no aprendizado
Quando vários contextos acessam SharedArrayBuffer, se as operações forem executadas no buffer ao mesmo tempo, podem ocorrer problemas de contenção de recursos. A API Atomics permite que vários contextos leiam e gravem com segurança um SharedArrayBuffer, forçando que apenas uma operação possa ser executada no buffer por vez.
A natureza das operações atômicas impede otimizações (como reordenação de instruções) que o sistema operacional ou hardware do computador normalmente executaria automaticamente. As operações atômicas também impossibilitam o acesso à memória simultaneamente. Se usadas incorretamente, podem causar lentidão na execução do programa. Por esse motivo, a intenção original do design da API Atomics é construir programas JavaScript multithread complexos baseados em mínimos, mas estáveis. comportamento atômico.
A API Atomics fornece um conjunto de métodos simples para realizar operações de modificação no local. Na especificação ECMA, esses métodos são definidos como operações AtomicReadModifyWrite. Nos bastidores, esses métodos leem um valor de um local no SharedArrayBuffer, executam operações aritméticas e bit a bit e, finalmente, gravam o resultado no mesmo local. A natureza atômica dessas operações significa que as operações de leitura, modificação e write-back descritas acima serão executadas em ordem e não serão interrompidas por outros threads.
//Cria um buffer de tamanho 1 let sharedArrayBuffer = new SharedArrayBuffer(1); //Cria Unit8Arraylet baseado no buffer typedArray = new Unit8Array(sharedArrayBuffer); //Todos os ArrayBuffers são inicializados em 0console.log(typedArray); //Unit8Array[0] //Executa a adição atômica de 10 ao valor no índice 0Atomics.add(typedArray,0,10); //Unit8Array[10] //Executa a subtração atômica de 10 no valor do índice 0Atomics.sub(typedArray,0,10); //Unit8Array[0]
O compilador JavaScript do navegador e a própria arquitetura da CPU têm autoridade para reorganizar instruções para melhorar a eficiência de execução do programa. Em circunstâncias normais, o ambiente de thread único do JavaScript pode realizar essa otimização a qualquer momento, mas o rearranjo de instruções em multithread pode levar à contenção de recursos e é extremamente difícil de solucionar.
A API Atomics resolve esse problema de duas maneiras principais:
A ordem de todas as instruções atômicas em relação umas às outras nunca é reorganizada.
O uso de leituras ou gravações atômicas garante que todas as instruções não sejam reordenadas em relação às leituras e gravações atômicas.
Além de ler e escrever valores de buffer, Atomics.load() e Atomics.store() também podem construir "cercas de código". O mecanismo JavaScript garante que instruções não atômicas possam ser reorganizadas localmente em relação a load() e store(), mas esse rearranjo não violará os limites de leituras e gravações atômicas.
const sharedArrayBuffer = novo SharedArrayBuffer(4); visualização const = novo Unit32Array(sharedArrayBuffer); //Executa gravação não atômica view[0] = 1; //A gravação não atômica pode ser garantida antes desta operação de leitura, então 1console.log(Atomics.load(view,0)); //1 //Executa gravação atômica Atomics.store(view,0,2); //A leitura não atômica pode ocorrer após a conclusão da escrita atômica, e 2console.log(view[0]); //2
Para garantir primeiro a leitura contínua e ininterrupta e depois a escrita, a API Atomics fornece dois métodos: exchange() e compareExchange(). Atomics.exchange() realiza uma troca simples que garante que outros threads não interromperão a troca.
const sharedArrayBuffer = novo SharedArrayBuffer(4); visualização const = novo Unit32Array(sharedArrayBuffer); //Escreve 10Atomics.store(view,0,10) no índice 0; //Leia o valor do índice 0 e escreva 5 no índice 0console.log(Atomics.exchange(view,0,5)); //10 //Lê o valor do índice 0 console.log(Atomics.load(view,0)); //5
Em um programa multithread, um thread só pode querer gravar em um buffer compartilhado se nenhum outro thread tiver modificado o valor desde a última vez que foi lido. Se o valor não tiver sido modificado, este thread poderá gravar com segurança o valor atualizado: se o valor tiver sido modificado, a execução de uma operação de gravação destruirá o valor calculado por outros threads. Para esse tipo de tarefa, a API Atomics fornece o método compare-Exchange(). Este método só executa a operação de gravação se o valor no índice de destino corresponder ao valor esperado.
Sem algum tipo de mecanismo de bloqueio, os programas multithread não podem suportar requisitos complexos. Para esse fim, a API Atomics fornece métodos que imitam o Linux Futex (fast user-space mutex). Esses métodos, embora muito simples em si, podem servir como componentes básicos para mecanismos de travamento mais complexos.
Todas as operações atômicas Futex só podem ser usadas em visualizações Int32Array e, além disso, apenas em threads de trabalho.
Mensagens entre documentos, às vezes também chamadas de XDM (mensagens entre documentos), são a capacidade de transferir informações entre diferentes contextos de execução (como diferentes threads de trabalho ou páginas de diferentes fontes).
API de codificação é usada principalmente para converter strings e arrays estereotipados.
A API de arquivo ainda é baseada no campo de entrada de arquivo no formulário, mas adiciona a capacidade de acessar diretamente as informações do arquivo. HTML5 adiciona uma coleção de arquivos ao DOM para elementos de entrada de arquivo. Quando o usuário seleciona um ou mais arquivos no campo de arquivo, a coleção de arquivos conterá um conjunto de objetos Arquivo representando os arquivos selecionados. Cada objeto Arquivo possui alguns atributos somente leitura.
O tipo FileReader representa um mecanismo assíncrono de leitura de arquivos. Você pode pensar em FileReader como semelhante a XMLHttpRequest, exceto que ele é usado para ler arquivos do sistema de arquivos em vez de ler dados do servidor. O tipo FileReader fornece vários métodos para leitura de dados de arquivo.
readAsText(file,encoding);//Lê o conteúdo de texto simples do arquivo e salva-o no atributo de resultado
readAsDataURL(file);//Lê o arquivo e salva o URI de dados do conteúdo no atributo de resultado
readAsBinaryString(file); //Lê o arquivo e salva os dados binários de cada caractere no atributo de resultado
readAsArrayBuffer(file); //Lê o arquivo e salva o conteúdo do arquivo no atributo de resultado na forma de ArrayBuffer
Uma versão síncrona do arquivo. Tipo de leitor de arquivos.
Em alguns casos, pode ser necessário ler parte do arquivo em vez do arquivo inteiro. Para isso, o objeto File fornece um método chamado slice(). O método slice() recebe dois parâmetros: o byte inicial e o número de bytes na área Yaodu. Este método retorna uma instância de Blob, que na verdade é uma superclasse de File.
Blob representa um objeto binário grande, que é o tipo de encapsulamento do JavaScript para dados binários não modificáveis. Arrays contendo strings, ArrayBuffers, ArrayBufferViews e até mesmo outros blobs podem ser usados para criar blobs. O construtor Blob pode receber um parâmetro de opções e especificar o tipo MIME nele.
A API Streams nasceu para resolver um problema simples, mas básico: como uma aplicação web consome pequenos blocos ordenados de informação em vez de grandes blocos de informação? Existem dois cenários principais de aplicação para esse recurso.
A API Streams define três fluxos:
Fluxo legível: um fluxo que pode ler blocos de dados por meio de uma interface pública. Os dados entram no fluxo internamente a partir da fonte subjacente e são então processados pelo consumidor.
Fluxo gravável: Um fluxo no qual blocos de dados podem ser gravados por meio de alguma interface pública. O produtor (consumidor) grava dados no fluxo e os dados são transferidos internamente para o slot de dados subjacente (sink).
Fluxo de conversão: consiste em dois fluxos, o fluxo gravável é usado para receber dados e o fluxo legível é usado para gerar dados. Essas duas verificações de qualidade de fluxo são transformadores que podem inspecionar e modificar o conteúdo do fluxo conforme necessário.
A API de criptografia da Web descreve um conjunto de ferramentas de criptografia que padroniza como o JavaScript implementa a criptografia de maneira segura e convencional. Essas ferramentas incluem gerar, usar e aplicar pares de chaves criptográficas, criptografar e descriptografar informações e gerar números aleatórios de maneira confiável.
Muitas pessoas usam Math.random() quando precisam gerar números aleatórios. Este método é implementado no navegador como um gerador de números pseudo-aleatórios (PRNG, PseudoRandom Number Generator). O chamado pseudo refere-se ao processo de geração de valores que não são verdadeiramente aleatórios. Os valores gerados pelo PRNG simulam apenas características aleatórias. O PRNG do navegador não usa uma fonte aleatória verdadeira, mas apenas aplica um algoritmo fixo a um estado interno. Cada vez que Math.random() é chamado, esse estado interno é modificado por um algoritmo e o resultado é convertido em um novo número aleatório. Por exemplo, o motor V8 usa um algoritmo chamado xorshift128+ para realizar esta modificação.
Como o algoritmo em si é fixo e sua entrada é apenas o estado anterior, a sequência de números aleatórios também é determinada. xorshift128+ usa estado interno de 128 bits e o algoritmo é projetado para que qualquer estado inicial gere 2 128 -1 valores pseudo-aleatórios antes de se repetir. Esse tipo de loop é chamado de loop de permutação e a duração desse loop é chamada de período. É óbvio que se o invasor conhecer o estado interno do PRNG, ele poderá prever os valores pseudoaleatórios gerados posteriormente. Se o desenvolvedor usar inadvertidamente o PRNG para gerar uma chave privada para criptografia, o invasor poderá usar esse recurso do PRNG para calcular a chave privada.
Os geradores de números pseudo-aleatórios são usados principalmente para calcular rapidamente números aparentemente aleatórios, mas não são adequados para algoritmos de criptografia. Para resolver esse problema, o gerador de números pseudo-aleatórios criptograficamente seguro (CSPRNG, Cryptographically Secure PseudoRandom Number Generator), adiciona adicionalmente uma entropia como. entrada, como testar o tempo de hardware ou outras características do sistema com comportamento imprevisível, embora não tão rápido quanto o PRNG, o valor gerado é mais difícil de prever e pode ser usado para criptografia.
A API de criptografia da Web apresenta CSPRNG, que pode ser acessado no objeto Crypto global por meio de crypto.getRandomValues() . Ao contrário de Math.random() que retorna um número de ponto flutuante entre 0 e 1, getRandomValues() grava valores aleatórios no array estereotipado passado a ele como parâmetro. A classe da matriz estereotipada não importa porque o buffer subjacente será preenchido com bits aleatórios.
