Este artigo demonstra principalmente o cenário de processamento concorrente de programação Java Programação por meio de usuários bancários retirando dinheiro, como segue.
Comece com um exemplo: implemente o código de exemplo para um cenário de retirada de conta bancária.
A primeira aula: Account.java
Categoria de conta:
pacote cn.edu.byr.test; public classe conta {private string contano; equilíbrio duplo privado; public conta () {} public conta (string accountNo, duplo equilíbrio) {this.accountno = accountNo; this.Balance = balances; getBalance () {return this.Balance;} public void SetBalance (Balance duplo) {this.balance = balance;} public boolean é igual (objeto obj) {if (this == obj) retorna true; if (obj! false;}} A segunda classe: drawthread.java
Classe de thread de retirada de dinheiro:
pacote cn.edu.byr.test; classe pública drawThread estende o thread {conta privada em conta; private duploousous; public drawthread (nome da string, conta de conta, drawAdamount) {super (name); this.account = conta; this.drawamount = drawamount;} public run () {// synchize (synchized. drawamount) {System.out.println (getName () + "Obtenha dinheiro com sucesso, cuspi as notas:" + drawAdount); // tente {// thread.sleep (1); //} // Catch (interruptEdException e) {// e.printStackTrace (); //} account.setBalance (account.getBalance () - drawAdount); System.out.println ("/t O saldo é:" + conta.getBalance ());} else System.out.println (getName () + "Retirar dinheiro falhado, o saldo é insuficiente!"); //}} public static void main (string [] args) {;; DrawThread ("A", Acct, 800) .Start (); New DrawThread ("B", Acct, 800) .Start ();}} A parte comentada no código acima: (1) bloco de código de sincronização sincronizado (2) hibernação do encadeamento. Se (1) e (2), existem muitas possibilidades para o resultado da execução, uma das possibilidades (a probabilidade é pequena), que está em conformidade com a lógica normal:
B retira dinheiro com sucesso, cospe o dinheiro: 800.0
O equilíbrio é: 200.0
Uma retirada fracassada e o saldo era insuficiente!
Deve ser que B primeiro encontre o recurso de retirada de dinheiro e modifique o saldo corretamente antes de começar a julgar o saldo do usuário; Essa probabilidade é muito pequena e a maioria das operações será semelhante às seguintes situações:
A retira dinheiro e cospe o dinheiro: 800.0
B retira dinheiro com sucesso, cospe o dinheiro: 800.0
O equilíbrio é: -600.0
O equilíbrio é: 200.0
Isso é obviamente ilógico. A partir dos resultados em execução, podemos adivinhar que primeiro apreende o recurso e retira o valor, mas antes de modificar o saldo, o recurso é apreendido por B; Como o saldo não foi modificado, B vê que o saldo ainda é 800 e B ainda retira o valor; Um primeiro executa o saldo da modificação, mas não o imprime, b arrebata o recurso; B modifica o equilíbrio e imprime o saldo, que é -600; A imprime o equilíbrio, que é 200;
Se (2) o encadeamento dorme, deve ser uma condição de erro, porque A ou B liberarão os recursos da CPU devido ao sono depois de buscar a quantidade e a JVM chamará outros processos no estado pronto. A segunda coisa é retirar dinheiro e julgar o saldo deve estar errado.
Se (1) bloco de código sincronizado sincronizado for adicionado, a conta será bloqueada no corpo do método de execução do encadeamento; Em seguida, a lógica de execução será garantida como normal sempre:
A retira dinheiro e cospe o dinheiro: 800.0
O equilíbrio é: 200.0
B falhou em retirar dinheiro, e o saldo era insuficiente!
Você pode imaginar o processo de execução:
Primeiro, antecede o recurso e bloqueia a classe de conta inicialmente no corpo do método de corrida; Em seguida, começa a executar o bloco de código síncrono; Se for executado em um certo link no meio, o recurso da CPU será antecipado por B; B começa a executar e bloqueia a classe de conta no início. No entanto, ao adicionar um bloqueio, você descobrirá que a conta foi ocupada por A, e ela será ajustada a um estado de bloqueio e esperará que um libere o recurso; Depois que A executar o bloco de código síncrono, o bloqueio da conta será liberado e B continuará sendo executado; O saldo observado durante a execução B é garantido para ser modificado por A e será executado normalmente de acordo com a lógica correta.
Resumir
O exposto acima é todo o conteúdo deste artigo sobre a análise de instâncias de processamento simultâneas multithreads da programação Java, e espero que seja útil para todos. Amigos interessados podem continuar se referindo a outros tópicos relacionados neste site. Se houver alguma falha, deixe uma mensagem para apontá -la. Obrigado amigos pelo seu apoio para este site!