Est-il possible pour un thread de Blocage lui-même?

Cela dépend de ce que tu veux dire par "blocage" exactement. Par exemple, vous pouvez facilement wait() sur un moniteur qui rien ne serait jamais impulsion... mais je ne pense pas que je ferais appel de cette impasse, en tant que tel.

La pensée le long de votre "méthode qui s'appelle" les lignes, si votre serveur n'a couru un certain nombre de fils, ils pourraient tous être occupé attente de réponses à partir du même serveur, si ce qui compte. (Exemple le plus simple: le serveur n'utilise qu'un seul thread pour le traitement. Si vous écrivez un gestionnaire de requêtes qui appelle dans le même serveur, il sera en attente pour le thread bloqué pour terminer le traitement de la demande avant qu'il puisse servir la même demande...) Ce n'est pas vraiment un "bloc synchronisé" une sorte de blocage, mais c'est certainement un danger pour l'être conscient.

EDIT: Pour appliquer cette réponse à la définition dans les autres, les actions concurrentes ici serait "valider la demande actuelle" et "gérer la nouvelle demande". Chaque action est en attente pour l'autre de se produire.

Peut-être ce que l'intervieweur a été pensée était:

Thread.currentThread().join();

Cependant, je dirais que ça ne compte pas comme un blocage.

Un blocage est une forme de l'insuffisance de ressources avec une interaction entre plusieurs threads.

Lorsqu'un fil est dans un état de ressource sauvant lui-même, il est renvoyé à un absence de cycle non productif qui est similaire à une impasse, mais pas de la même façon par définition.

Un exemple d'une absence de cycle non productif est à l'aide de ReentrantReadWriteLock. En dépit d'être réentrant de lecture OU d'écriture, il ne permet pas la mise à niveau de la serrure de lire pour écrire.

public class LiveLock {
    public static void main(String[] args) {
        ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
        lock.readLock().lock();
        if (someCondition()) {
            //we want to write without allowing another thread to jump in.
            lock.writeLock().lock();
        }
    }

    private static boolean someCondition() {
        return true;
    }
}

résultats dans le processus de blocage ici

"main" #1 prio=5 os_prio=0 tid=0x0000000002a52800 nid=0x550c waiting on condition [0x000000000291f000]
   java.lang.Thread.State: WAITING (parking)
    at sun.misc.Unsafe.park(Native Method)
    - parking to wait for  <0x00000007162e5e40> (a java.util.concurrent.locks.ReentrantReadWriteLock$NonfairSync)
    at java.util.concurrent.locks.LockSupport.park(LockSupport.java:175)
    at java.util.concurrent.locks.AbstractQueuedSynchronizer.parkAndCheckInterrupt(AbstractQueuedSynchronizer.java:836)
    at java.util.concurrent.locks.AbstractQueuedSynchronizer.acquireQueued(AbstractQueuedSynchronizer.java:870)
    at java.util.concurrent.locks.AbstractQueuedSynchronizer.acquire(AbstractQueuedSynchronizer.java:1199)
    at java.util.concurrent.locks.ReentrantReadWriteLock$WriteLock.lock(ReentrantReadWriteLock.java:943)
    at LiveLock.main(LiveLock.java:10)

Une question connexe est de savoir; un fil d'arriver dans une impasse sans créer de nouveaux threads. C'est possible car il y a des threads d'arrière-plan par exemple, le finaliseur fil, qui permet d'exécuter le code de l'utilisateur dans l'arrière-plan. Cela permet pour le thread principal et le finaliseur fil de l'impasse les uns des autres.

La JVM ne garde la trace du fil local qui a l'écran, si la classe d'appel rend un appel externe sur lui-même à l'appel entrant provoque le thread d'origine de blocage lui-même.

Vous devriez être en mesure d'exécuter ce code pour illustrer l'idée

import java.rmi.*;
import java.rmi.registry.LocateRegistry;
import java.rmi.registry.Registry;
import java.rmi.server.*;
public class DeadlockThreadExample {
public static interface DeadlockClass extends Remote {
public void execute() throws RemoteException;
}
public static class DeadlockClassImpl extends UnicastRemoteObject implements DeadlockClass {
private Object lock = new Object();
public DeadlockClassImpl() throws RemoteException {
super();
}
public void execute() throws RemoteException {
try {
System.out.println("execute()::start");
synchronized (lock) {
System.out.println("execute()::Entered Lock");
DeadlockClass deadlockClass = (DeadlockClass) Naming.lookup("rmi://localhost/DeadlockClass");
deadlockClass.execute();
}
System.out.println("execute()::Exited Lock");
} catch (NotBoundException e) {
System.out.println(e.getMessage());
} catch (java.net.MalformedURLException e) {
System.out.println(e.getMessage());
}
System.out.println("execute()::end");
}
}
public static void main(String[] args) throws Exception {
LocateRegistry.createRegistry(Registry.REGISTRY_PORT);
DeadlockClassImpl deadlockClassImpl = new DeadlockClassImpl();
Naming.rebind("DeadlockClass", deadlockClassImpl);
DeadlockClass deadlockClass = (DeadlockClass) Naming.lookup("rmi://localhost/DeadlockClass");
deadlockClass.execute();
System.exit(0);
}
}

La sortie du programme ressemble

execute()::start
execute()::Entered Lock
execute()::start

En outre, le fil de vidage est le suivant

"main" prio=6 tid=0x00037fb8 nid=0xb80 runnable [0x0007f000..0x0007fc3c]
at java.net.SocketInputStream.socketRead0(Native Method)
at java.net.SocketInputStream.read(SocketInputStream.java:129)
at java.io.BufferedInputStream.fill(BufferedInputStream.java:218)
at java.io.BufferedInputStream.read(BufferedInputStream.java:235)
- locked <0x02fdc568> (a java.io.BufferedInputStream)
at java.io.DataInputStream.readByte(DataInputStream.java:241)
"RMI TCP Connection(4)-172.17.23.165" daemon prio=6 tid=0x0ad83d30 nid=0x1590 waiting for monitor entry [0x0b3cf000..0x0b3cfce8]
at DeadlockThreadExample$DeadlockClassImpl.execute(DeadlockThreadExample.java:24)
- waiting to lock <0x0300a848> (a java.lang.Object)
at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)
"RMI TCP Connection(2)-172.17.23.165" daemon prio=6 tid=0x0ad74008 nid=0x15f0 runnable [0x0b24f000..0x0b24fbe8] 
at java.net.SocketInputStream.socketRead0(Native Method)
at java.net.SocketInputStream.read(SocketInputStream.java:129)
at java.io.BufferedInputStream.fill(BufferedInputStream.java:218)
at java.io.BufferedInputStream.read(BufferedInputStream.java:235)
- locked <0x02ffb6d8> (a java.io.BufferedInputStream)
at java.io.DataInputStream.readByte(DataInputStream.java:241)

qui indique que le thread a en effet réussi à verrouiller lui-même

Alors que je n'ai pas utilisé de Java, j'ai dans l'impasse d'un seul thread de l'application avant de l'. IIRC: Routine verrouillé un morceau de données à mettre à jour. Routine B également verrouillé, le même morceau de données à mettre à jour. En raison de changements dans les exigences d'Un fini par appeler B. Oups.

Bien entendu, c'était juste un ordinaire de développement bug que j'ai attrapé la première fois que j'ai essayé d'exécuter le code, mais il n'a blocage lui-même. Je pense que les blocages de ce type serait possible dans une langue qui prend en charge un système de fichiers.

Vous pouvez obtenir vous-même dans un thread unique de Blocage avec ReentrantReadWriteLock. Des verrous en écriture peuvent acquérir des verrous en lecture, mais pas l'inverse. Le suivant va bloquer indéfiniment.

    ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
lock.readLock().lock();
lock.writeLock().lock();

Ici un moyen pour un thread de blocage lui-même.

public class DeadlockMe
{
public static void main(String[] args)
{
DeadlockThing foo = new DeadlockThing();
synchronized(foo)
{
try
{
foo.wait();
}
catch (InterruptedException e)
{
e.printStackTrace();
}
}
}
}

Le thread crée une instance d'une classe - toute la classe et il attend d'elle. Parce que le thread créé un objet avec une portée locale, il n'y a aucun moyen possible pour n'importe quel autre thread pour notifier l'objet de réveiller le fil.

Si vous tirez sur la définition de la durée de blocage: un seul thread peut se trouver bloqué sur un non réentrant de verrouillage qu'il avait pris plus tôt.

Je sais que c'est un vieux post. Voici un autre exemple de la façon dont cela pourrait se produire si votre code a l'interaction avec les ressources externes:

J'ai un fil, que d'ouvrir une connexion de base de données, démarrer une transactionA, et de commencer à mettre à jour. Le même thread, ouvrir une autre connexion, commencer un autre transactionB. Cependant, parce que transactionA n'a pas commis, et il a table de base de données verrouillée, transactionB qui se passe pour accéder à cette table verrouillée, donc il doit attendre

En fin de compte le même thread est bloquer par lui-même, car elle a ouvert plus d'une connexion de base de données.

Ce qui s'est passé beaucoup de choses dans l'application que j'ai de travailler avec, car il existe de nombreux modules de l'application, et un thread peut s'exécuter même si de nombreuses méthodes. Ces méthodes s'ouvre leurs propres connexions. Depuis nous avons eu différents développeurs d'écrire leur code, ils ne peuvent pas voir la façon dont leur code commencent appelé, et ne pouvait donc pas voir l'ensemble des transactions de base de données ouvert par l'application.

Bien que les commentaires ici sont d'être pointilleux à propos de "blocage" qui se passe si au moins deux threads/actions sont en compétition pour la même ressource...je pense que l'esprit de cette question était de discuter de la nécessité pour Réentrant lock - en particulier dans le contexte de "récursive" verrouillage

Voici un exemple en python (je suis certain que le concept reste le même en Java):
Si vous modifiez le RLock de Verrouillage (c'est à dire réentrant de verrouillage pour verrouiller, le thread se bloque)

import threading
"""
Change RLock to Lock to make it "hang"
"""
lock = threading.Condition(threading.RLock())
def print_list(list):
lock.acquire()
if not list:
lock.release()
return
print(list[0])
print_list(list[1:])
lock.release()
print_list([1, 2, 3, 4, 5])