1. Prioridade dos threads
Exemplos de uso de prioridade do tópico:
pacote cn.galc.test; public class TestThread6 {public static void main (string args []) {mythread4 t4 = new mythread4 (); Mythread5 t5 = novo mythread5 (); Thread t1 = novo thread (t4); Tópico T2 = novo thread (T5); t1.setPriority (Thread.norm_priority + 3); // use o método setPriority () para definir a prioridade dos threads, e aqui a prioridade dos threads T1 é definida/** Aumente a prioridade da linha T1 por nível 3 na base da prioridade normal (norma_PRIOR)* De essa maneira, a parte de exceção da T1 será muito */ t1.start (); t2.start (); System.out.println ("A prioridade do thread t1 é:" + t1.getPriority ()); // Use o método getPriority () para obter a prioridade do thread e imprimir a prioridade de t1 ser 8}} classe mythread4 implementa runnable {public void run () {for (int i = 0; i <= 1000; i ++) {System.out.println ("t1:"+i); }}} classe mythread5 implementa runnable {public void run () {for (int i = 0; i <= 1000; i ++) {System.out.println ("=================== T2:"+i); }}} Assim que o método run () termina, o thread termina.2. Sincronização de roscas
Exemplos de uso de palavras -chave sincronizadas:
pacote cn.galc.test; classe pública testsync implementa Runnable {Timer Timer = new Timer (); public static void main (string args []) {testsync test = new testsync (); Thread t1 = novo thread (teste); Tópico T2 = novo thread (teste); t1.setName ("t1"); // Defina o nome do thread t1 t2.SetName ("t2"); // Defina o nome do thread t2 t1.start (); t2.start (); } public void run () {timer.add (thread.currentThread (). getName ()); }} classe Timer {private static int num = 0; public/ * sincronizado */void add (nome da string) {// Ao adicionar sincronizado ao declarar um método, significa que o objeto atual é bloqueado durante a execução desse método sincronizado (this) {/ * * use síncronizado (this) para bloquear o objeto atual, para que não haja problema de dois threads diferentes. Somente quando um thread acessos será a virada do próximo thread para acessar */ num ++; tente {thread.sleep (1); } catch (interruptedException e) {e.printStackTrace (); } System.out.println (nome + ": você é os threads" + num + "usando o timer"); }}} Problema de deadlock thread:
pacote cn.galc.test;/*Este applet simula o problema do encadeamento de fios*/classe pública TestDeadlock implementa runnable {public int sinalizador = 1; Objeto estático O1 = new Object (), O2 = new Object (); public void run () {System.out.println (thread.currentThread (). getName () + "flag =" + flag); /** Depois de executar o programa, descobri que o programa o executou e imprimiu a bandeira, e nunca vou executar a declaração se subsequente novamente* o programa morreu aqui, nem executando nem saindo*//* Este é o sinalizador de thread = 1*/ if (sinalizador == 1) {synchron (o1) {/ use o use o synchronese para locks 01; } catch (interruptedException e) {e.printStackTrace (); } sincronizado (O2) { /** Objeto O1 já foi bloqueado antes, desde que possa bloquear O2, você pode executar a operação de imprimir 1* No entanto, o objeto O2 não pode ser bloqueado aqui, porque o objeto O1 foi bloqueado em outro sinalizador de rosca. } } } } /* * Both if statements here will not be executed because they have caused the problem of thread deadlock* flag=1 This thread is waiting for flag=0 This thread is unlocking the lock of object o2, * And flag=0 This thread is also waiting for flag=1 This thread unlocking the lock of object o1* However, neither of these threads are willing to unlock the locked object, so it causes the problem of thread deadlock*/ /* This is the thread sinalizador = 0*/ if (sinalizador == 0) {sincronizado (o2) {/*Aqui usamos sincronizados para bloquear o objeto O2 primeiro*/ tente {thread.sleep (500); } catch (interruptedException e) {e.printStackTrace (); } sincronizado (O1) { / * * Objeto O2 já foi bloqueado antes. Contanto que possa bloquear O1, a operação de impressão 0 pode ser executada. No entanto, o objeto O1 não pode ser bloqueado aqui, porque o objeto O1 foi bloqueado em outro thread de sinalizador = 1. Embora o thread que trava o objeto O1 durma a cada 500 milissegundos, ele ainda trava o1 ao dormir*/ System.out.println ("0"); }}}} public static void main (string args []) {testDeadlock td1 = new testDeadlock (); TestDeadlock td2 = new TestDeadlock (); td1.flag = 1; td2.flag = 0; Thread t1 = novo thread (td1); Tópico T2 = novo thread (TD2); t1.setName ("Thread td1"); T2.SetName ("Thread Td2"); t1.start (); t2.start (); }}É melhor resolver o problema de encadeamento de fios, apenas um objeto, não dois objetos ao mesmo tempo.
Perguntas para produtores e consumidores:
pacote cn.galc.test;/* Exemplo Nome: Produtor-Problema do consumidor* Nome do arquivo de origem: produterConsumer.java* Pontos-chave:* 1. Stack = new SyncStack (); Punnable p = novo produtor (pilha); Executável c = novo consumidor (pilha); Tópico P1 = novo thread (P); Thread c1 = novo thread (c); p1.start (); c1.start (); }} classe SyncStack {// Implementação de pilhas que suportam operações de sincronização multithread Private Int Index = 0; Char privado [] dados = novo char [6]; public sincronizado void push (char c) {if (index == data.length) {try {this.wait (); } catch (interruptedException e) {}} this.Notify (); dados [index] = c; índice ++; } public sincronizado char pop () {if (index == 0) {try {this.wait (); } catch (interruptedException e) {}} this.Notify (); índice--; retornar dados [índice]; }} Classe Produtor implementa Runnable {SyncStack Stack; Produtor público (SyncStack S) {Stack = S; } public void run () {for (int i = 0; i <20; i ++) {char c = (char) (math.random ()*26+'a'); Stack.push (c); System.out.println ("Produzido:"+C); tente {thread.sleep ((int) (math.random ()*1000)); } catch (interruptEdException e) {}}}} classe de consumidor implementa o runnable {syncstack pilha; consumidor público (SyncStack s) {Stack = s; } public void run () {for (int i = 0; i <20; i ++) {char c = pilha.pop (); System.out.println ("Consumo:"+C); tente {thread.sleep ((int) (math.random ()*1000)); } catch (interruptedException e) {}}}}O exposto acima é a introdução completa aos threads java. Você pode combinar o primeiro artigo "Java deve aprender e aprender threads (1)" para aprender, esperando que ele possa ajudá -lo.