Si une méthode synchronisée appels à un autre non-méthode synchronisée, est-il un verrou sur la non-méthode synchronisée

Si une méthode synchronisée appels à un autre non-méthode synchronisée, est-il un verrou sur la non-méthode synchronisée

Oui et non.

Si vous êtes dans un synchronized méthode, puis des appels à d'autres méthodes sont également synchronized par d'autres threads sont bloqués. Toutefois, les appels à la non-synchronisé méthodes par d'autres threads sont pas verrouillé -- n'importe qui peut appeler, à la même période.

public synchronized void someSynchronizedMethod() {
    ...
    someNonSynchronizedMethod();
    ...
}

//anyone can call this method even if the someSynchronizedMethod() method has
//been called and the lock has been locked
public void someNonSynchronizedMethod() {
   ...
}

Aussi, si vous appelez someSynchronizedMethod() mais arriver à être à l'intérieur de la someNonSynchronizedMethod() méthode, vous détenez toujours la serrure. Le verrou est activé lorsque vous entrez dans un bloc synchronisé et est désactivé lorsque vous quittez cette méthode. Vous pouvez appeler toutes sortes d'autres méthodes non synchronisées et ils seront encore verrouillé.

Mais vous demandons deux choses différentes dans votre question:

En Java, si une méthode synchronisée contient un appel à une non-synchronisés, peut-être une autre méthode encore accès à la non-méthode synchronisée en même temps?

Oui. D'autres méthodes peuvent accéder à des non-synchronisé méthodes.

Fondamentalement, ce que je demande, tout est dans la méthode synchronisée avoir un verrou sur elle (y compris les appels à d'autres méthodes synchronisées)?

Euh, oui. D'autres appels à synchronisé méthodes sont verrouillés. Mais non synchronisée méthodes ne sont pas verrouillées.

Aussi, n'oubliez pas que si la méthode est static le verrou est sur le Class objet dans le ClassLoader.

//this locks on the Class object in the ClassLoader
public static synchronized void someStaticMethod() {

Si la méthode est une méthode d'instance, puis le verrou est sur l'instance de la classe.

//this locks on the instance object that contains the method
public synchronized void someInstanceMethod() {

Il y a 2 serrures différentes dans les 2 cas.

Enfin, lorsque vous traitez avec des synchronized méthodes d'instance, chaque instance de la classe est ce qui est verrouillé. Cela signifie que deux threads peuvent être dans le même synchronized méthode en même temps avec différents instances. Mais si les 2 threads tentent d'opérer sur synchronized méthodes sur le même exemple, on bloquera jusqu'à ce que l'on sort de la méthode.

La serrure n'appartient pas à la discussion. La serrure appartient réellement à l'objet(ou de la Classe en cas de niveau de la Classe lock), et un fil acquiert un verrou sur l'Objet(ou de la Classe en cas de niveau de la Classe lock) dans un synchronisé contexte.
Maintenant, il n'y a pas de verrouillage de la propagation dans java comme il est discuté ci-dessus. Voici une petite démo:

public class TestThread {

/**
 * @param args
 * @throws InterruptedException 
 */
public static void main(String[] args) throws InterruptedException {
    //TODO Auto-generated method stub
    ThreadCreator1 threadCreator1 = new ThreadCreator1();
    ThreadCreator2 threadCreator2 = new ThreadCreator2();

    Thread t1 = new Thread(threadCreator1,"Thread 1");
    Thread t3 = new Thread(threadCreator1,"Thread 3");
    Thread t2 = new Thread(threadCreator2,"Thread 2");

    t1.start();
    Thread.sleep(2000);
    t3.start();

}

}

public class ThreadCreator1 implements Runnable {

private static final Task task= new Task();
private static final Task2 task2= new Task2();

@Override

public void run() {

    try {

        if(Thread.currentThread().getName().equals("Thread 1"))
            task.startTask2(task2);
        if(Thread.currentThread().getName().equals("Thread 3"))
            task2.startTask();

    } catch (InterruptedException e) {
        //TODO Auto-generated catch block
        e.printStackTrace();
    }
    //TODO Auto-generated method stub

    /**/

    }
}

public class Tâche {

public static final Task task = new Task();
public static List<String> dataList = new ArrayList<String>();
ReentrantLock lock =  new ReentrantLock();



public  void startTask2(Task2 task2) throws InterruptedException
{

    try{

        lock.lock();
        //new Task2().startTask();
        task2.startTask();
    }
    catch(Exception e)
    {

    }
    finally{
        lock.unlock();
    }
}

}

public class Task2 {

ReentrantLock lock = new ReentrantLock();
public  void startTask() throws InterruptedException
{

    try{
        //lock.lock();
        for(int i =0 ;i< 10;i++)
    {
        System.out.println(" *** Printing i:"+i+" for:"+Thread.currentThread().getName());
        Thread.sleep(1000);
    }
    }
    catch(Exception e)
    {

    }
    /*finally
    {
        lock.unlock();
    }*/
}

}

Juste que j'ai utilisé Réentrant de verrouillage ici.
Si le code ci-dessus est exécuté, puis il y aura l'entrelacement entre le 1 et le fil 3, mais si le verrouillage de la partie de Task2 classe est sans commentaire, alors il n'y aura pas d'entrelacement et le fil qui acquérir le verrou de la première, sera complète entièrement en premier, puis il va la libérer, puis l'autre thread peut s'exécuter sur.