Являются ли wait() и notify() ненадежными, несмотря на синхронизацию?

В чем проблема? Ну, а если работающий поток не ждет, то он не увидит никаких уведомлений (т.е. вызовов notify()), поэтому может попасть в мёртвую блокировку и не обработать полученные задачи!

Верно. Это не случай «ненадежности», а скорее случай определения языка. Вызов notify() не ставит уведомления в очередь. Если нет ожидающих потоков, то notify() фактически ничего не сделает.

можно ли сделать проще?

Да. Я бы рассмотрел возможность использования BlockingQueue -- LinkedBlockingQueue должен хорошо работать для вас. Один поток вызывает pull из очереди, а другой может добавлять в нее. Он позаботится о блокировке и сигнализации для вас. Вы должны быть в состоянии удалить большую часть вашего рукописного кода, как только вы начнете его использовать.

Сначала я был обманут вашим вопросом. Ваша синхронизация (это) в объекте потока не имеет смысла. Раньше я также делал это, чтобы wait() не выдавало ошибку компиляции.

Только синхронизация (задачи) имеет смысл, поскольку вы ждете и хотите получить эти ресурсы.

Имея цикл for, это плохой дизайн. В проблеме потребитель-производитель. получить работу в то же время удалить работу. лучше получить работу один раз за раз.

public void do(Job job){
    synchronized(tasks){
        tasks.add(job);
        notify();
    }
}

public void run(){
    Job job;
    while(true){

        //This loop will fetch the task or wait for task notification and fetch again.
        while (true){
            synchronized(tasks){
                if(tasks.size()>0){
                    job = tasks.getTask(0);
                    break;
                }
                else
                    wait();

            }
        }

        //do some job here...

    }
}

На самом деле результатом является не тупиковая блокировка, а скорее зависание самой задачи/задания. Поскольку никакие потоки не «заблокированы», задача просто не будет выполнена, пока другой поток не вызовет do(Job job).

Ваш код почти правильный - помимо отсутствующей обработки исключений при вызове wait() и notify(). Но вы можете поместить task.size() в блок синхронизации и заблокировать задачи во время процесса дыры, потому что удаление задания внутри задач другим потоком приведет к сбою цикла:

...
while(true){
    synchronized(tasks){
        for (int = 0;i<tasks.size();i++){ //could be done without synchronisation
           Job job = tasks.get(i);        //if noone deletes any tasks
        }
        //do some job here...
    }
    ...

Просто обратите внимание, что ваш код блокирует. Неблокировка может быть быстрее и выглядеть так:

ArrayList <Job> tasks;
...

public void do(Job job){
    synchronized(tasks){
        tasks.add(job);
    }
}

public void run(){
    while(true){
        int length;
        synchronized(tasks){
            length = tasks.size();
        }
        for (int = 0;i<length;i++){
            Job job = tasks.get(i); //can be done without synchronisation if noone deletes any tasks...otherwise it must be within a synchronized block
            //do some job here...
        }
        wait(1); //wait is necessary and time can be set higher but never 0!
    }
}

Чему мы можем научиться? Ну, в неблокирующих потоках никакие notify(), wait() и synchronized не нужны. И установка ожидания (1) даже не использует больше ЦП в режиме ожидания (не устанавливайте ожидание (0), потому что это будет рассматриваться как ожидание ().

Однако будьте осторожны, поскольку использование wait(1) может быть медленнее, чем использование wait() и notify(): -efficient-than-using-wait-a">Является ли wait(1) в неблокирующем цикле while(true) более эффективным, чем использование wait() и notify()? (Другими словами: не -блокировка может быть медленнее, чем блокировка!)