síncrono
Para executar uma tarefa, precisamos contar com a conclusão de outra tarefa.
fluxo de execução do programa padrão é sincronizado apenas em uma execução da função é concluída, a próxima função antes de poderem começar, esta é a dependência
assíncrono
Para executar uma tarefa, não contam com a conclusão de outra tarefa.
O conceito de concorrência, só precisa dizer a necessidade de fazer outra tarefa, ele irá diretamente para o Executivo
bloqueio objeto: Só quando competindo para o mesmo alvo
- modificação sincronizado
非静态方法,代码块synchronized (this),synchronized (非this对象)código de sincronização de segmento para ser executado necessidade de adquirir correspondente a fechadura objecto
método de bloqueio
Um exemplo do primeiro show não bloquear, de acordo com o seu código de saída pode saber, porque nós instanciar um objeto e, em seguida, abra uma linha para passar um parâmetro ano passado, para executar System.out.println("a arrived");ele começou a 2s do sono, isso ao mesmo aberta o tempo outro segmento, a mesma chamada para o mesmo método do mesmo objecto, transmitido bno passado, por isso, existem os seguintes resultados
public class main {
public static void main(String[] args) throws IOException {
person p = new person();
new Thread(new Runnable() {
@Override
public void run() {
// TODO Auto-generated method stub
try {
p.addstr("a");
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}).start();
new Thread(new Runnable() {
@Override
public void run() {
// TODO Auto-generated method stub
try {
p.addstr("b");
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}).start();
}
}
class person{
private int number = 0;
public void addstr(String string) throws InterruptedException {
if (string.equals("a")) {
number = 100;
System.out.println("a arrived");
Thread.sleep(2000);
}else {
number = 200;
System.out.println("b arrived");
}
System.out.println(string + " number=" + String.valueOf(number));
}
}
saída:
a arrived
b arrived
b number=200
a number=200
Pequenas alterações ao addstrmétodo mais de bloqueio, este tempo competindo método de bloqueio de multi-threaded do mesmo objecto, é necessário, a fim de ter que esperar numa chamada para libertar o bloqueio
class person{
private int number = 0;
synchronized public void addstr(String string) throws InterruptedException {
if (string.equals("a")) {
number = 100;
System.out.println("a arrived");
Thread.sleep(2000);
}else {
number = 200;
System.out.println("b arrived");
}
System.out.println(string + " number=" + String.valueOf(number));
}
}
Outro caso é, um método de bloqueio de duas classes, dois segmentos diferentes ao mesmo tempo chama o objecto protegido, neste caso, após o teste, a exibição de saída, um segundo método para a realização de necessidade bloqueado para esperar, que é 一个类内，使用一个锁，锁住一个或多个方法.
person p = new person();
new Thread(new Runnable() {
@Override
public void run() {
// TODO Auto-generated method stub
try {
p.printA(string);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}).start();
new Thread(new Runnable() {
@Override
public void run() {
// TODO Auto-generated method stub
try {
p.printB(string);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}).start();
}
}
class person{
private int number = 0;
synchronized public void printA(String string) throws InterruptedException {
System.out.println("A 进入线程！");
Thread.sleep(2000);
System.out.println("A 离开线程！");
}
synchronized public void printB(String string) throws InterruptedException {
System.out.println("B 进入线程！");
System.out.println("B 离开线程！");
}
}
saída:
A 进入线程！
A 离开线程！
B 进入线程！
B 离开线程！
sincronizado (este)
A classe pessoa acima novamente ligeira modificação, nós bloquear um bloco de código, vários segmentos quando a mesma 竞争同一个对象é 这个代码块necessária para bloqueio de acordo com as regras, um comunicado, antes do próximo uso, o supra saída
class person{
private int number = 0;
public void addstr(String string) throws InterruptedException {
synchronized(this) {
if (string.equals("a")) {
number = 100;
System.out.println("a arrived");
Thread.sleep(2000);
}else {
number = 200;
System.out.println("b arrived");
}
System.out.println(string + " number=" + String.valueOf(number));
}
}
}
Deve-se notar isso porque multithreading regras de concorrência apenas os conteúdos deste bloco de código é o uso de bloqueios, que é o bloco de código acima, o seguinte não são sincronizados, modificar o código, o bloco de código de sincronização acima deste, mais o seguinte duas saídas System.out.println(string + "来了");、System.out.println(string + " number=" + String.valueOf(number));, desta vez a saída dos dois resultados seguintes. Um primeiro explicou b来了saída, porque System.out.println(string + "来了");este não fez lock, por isso, o primeiro parâmetro com um atempo de sono, o segundo segmento em execução para concluir a saída aqui b来了, ele está aqui para ficar, ocupando um segmento libera o bloqueio, ele pode continuar. Como resultado, há dois, é porque outra declaração de saída System.out.println(string + " number=" + String.valueOf(number));desbloqueado, totalmente, dependendo do que rápido, que executa, ou a execução simultânea são possíveis
class person{
private int number = 0;
public void addstr(String string) throws InterruptedException {
System.out.println(string + "来了");
synchronized(this) {
if (string.equals("a")) {
number = 100;
System.out.println("a arrived");
Thread.sleep(2000);
}else {
number = 200;
System.out.println("b arrived");
}
}
System.out.println(string + " number=" + String.valueOf(number));
}
}
saída:
a来了
a arrived
b来了
b arrived
a number=100
b number=200
ou
a来了
a arrived
b来了
b arrived
b number=200
a number=200
Mesma, de forma sincronizada (este) também existe na mesma classe, ou usando um bloqueio com uma pluralidade de blocos de código, o bloco de código não é o sincronismo vertical
class person{
public String son;
public person(String son) {
this.son = son;
}
private int number = 0;
synchronized public void printA(String string) throws InterruptedException {
System.out.println("A 进入线程！");
Thread.sleep(2000);
System.out.println("A 离开线程！");
}
public void printB(String string) throws InterruptedException {
System.out.println("B ready!");
synchronized (this) {
System.out.println("B 进入线程！");
System.out.println("B 离开线程！");
}
}
saída:
A 进入线程！
B ready!
A 离开线程！
B 进入线程！
B 离开线程！
sincronizado (este não-alvo)
Enquanto um objeto com vários segmentos acessar o objeto está bloqueado, e o mesmo, precisamos de bloqueio de acordo com as regras, como o exemplo a seguir, embora os exemplos de dois objetos diferentes, mas eles são o mesmo acesso um objeto string, não há concorrência. Na verdade, pode ser rotulada como um objeto bloqueado, qualquer uso deste segmento está bloqueado objeto, o equivalente de ser marcadas, etiquetadas local de execução thread para declaração sincronizado, é necessário ordem, não há nenhum concorrente continuar
public static void main(String[] args) throws IOException {
String string = "son";
person p = new person(string);
person p1 = new person(string);
new Thread(new Runnable() {
@Override
public void run() {
// TODO Auto-generated method stub
try {
p.addstr("a");
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}).start();
new Thread(new Runnable() {
@Override
public void run() {
// TODO Auto-generated method stub
try {
p1.addstr("b");
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}).start();
}
}
class person{
public String son;
public person(String son) {
this.son = son;
}
private int number = 0;
public void addstr(String string) throws InterruptedException {
System.out.println(string + "来了");
synchronized(son) {
if (string.equals("a")) {
number = 100;
System.out.println("a arrived");
Thread.sleep(2000);
}else {
number = 200;
System.out.println("b arrived");
}
}
System.out.println(string + " number=" + String.valueOf(number));
}
}
Locks
- modificação sincronizado
静态方法,synchronized(类.class)o bloqueio é a classe correspondente, é preciso obter类锁
bloqueio classe é, na verdade, a utilização da fechadura objecto, quando o carregamento de um ficheiro de classe, cria uma instância da classe java.lang.Class, uma classe quando a fechadura está bloqueada java. exemplos de lang.Class classe
O exemplo seguinte é 对象锁o uso diferente person对象, isto é, a utilização de bloqueio diferente com o objecto pessoa
String string = "son";
person p = new person(string);
person p1 = new person(string);
new Thread(new Runnable() {
@Override
public void run() {
// TODO Auto-generated method stub
try {
p.printA(string);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}).start();
new Thread(new Runnable() {
@Override
public void run() {
// TODO Auto-generated method stub
try {
p1.printB(string);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}).start();
}
}
class person{
public String son;
public person(String son) {
this.son = son;
}
private int number = 0;
synchronized public void printA(String string) throws InterruptedException {
System.out.println("A 进入线程！");
Thread.sleep(2000);
System.out.println("A 离开线程！");
}
synchronized public void printB(String string) throws InterruptedException {
System.out.println("B ready!");
System.out.println("B 进入线程！");
System.out.println("B 离开线程！");
}
}
对象锁saída:
A 进入线程！
B ready!
B 进入线程！
B 离开线程！
A 离开线程！
Além disso, pequenas alterações static, vamos usar 类锁, mesmo que as instâncias de objetos diferentes, mas o uso da mesma classe, a saída neste momento não é o mesmo, também é usado同一个类，使用一个锁锁住一个或多个方法、代码块
class person{
public String son;
public person(String son) {
this.son = son;
}
private int number = 0;
synchronized public static void printA(String string) throws InterruptedException {
System.out.println("A 进入线程！");
Thread.sleep(2000);
System.out.println("A 离开线程！");
}
synchronized public static void printB(String string) throws InterruptedException {
System.out.println("B ready!");
System.out.println("B 进入线程！");
System.out.println("B 离开线程！");
}
}
saída:
A 进入线程！
A 离开线程！
B ready!
B 进入线程！
B 离开线程！
Mais uma vez a introdução de um pequeno ponto experiência: 类锁e 对象锁misturar
o mesmo método, utilizando o código de cima é ligeiramente modificada, pode ser visto a partir da saída, o bloqueio dos objectos de blocos de código, até mesmo para o mesmo objecto, não há nenhum mecanismo de bloqueio realizada, ilustrando类锁和对象锁混用的情况下，只有类锁有效，对象锁无效
isto: o objeto representado pela instância atual da classe
person p = new person(string);
new Thread(new Runnable() {
@Override
public void run() {
// TODO Auto-generated method stub
try {
p.printA(string);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}).start();
new Thread(new Runnable() {
@Override
public void run() {
// TODO Auto-generated method stub
try {
p.printB(string);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}).start();
}
}
class person{
public String son;
public person(String son) {
this.son = son;
}
private int number = 0;
synchronized public static void printA(String string) throws InterruptedException {
System.out.println("A 进入线程！");
Thread.sleep(2000);
System.out.println("A 离开线程！");
}
public void printB(String string) throws InterruptedException {
System.out.println("B ready!");
synchronized (this) {
System.out.println("B 进入线程！");
System.out.println("B 离开线程！");
}
}
}
A fim de provar que a ordem não importa e fechaduras, inverter a fim de provar
class person{
public String son;
public person(String son) {
this.son = son;
}
private int number = 0;
public void printA(String string) throws InterruptedException {
System.out.println("A ready!");
synchronized (this) {
System.out.println("A 进入线程！");
Thread.sleep(2000);
System.out.println("A 离开线程！");
}
}
synchronized public static void printB(String string) throws InterruptedException {
System.out.println("B 进入线程！");
System.out.println("B 离开线程！");
}
}
saída:
A ready!
A 进入线程！
B 进入线程！
B 离开线程！
A 离开线程！
