Следует ли синхронизировать метод запуска? Почему или почему нет?

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

Теоретически существует еще один гораздо более сложный сценарий, в котором вы можете захотеть синхронизировать метод run(), который снова включает совместное использование Runnable несколькими потоками, но также использует wait() и notify(). Я никогда не сталкивался с этим за более чем 21 год Java.

Существует 1 преимущество использования synchronized void blah() по сравнению с void blah() { synchronized(this) {, и это то, что ваш результирующий байт-код будет на 1 байт короче, поскольку синхронизация будет частью сигнатуры метода, а не операцией сама по себе. Это может повлиять на возможность встраивания метода JIT-компилятором. В остальном нет никакой разницы.

Лучший вариант — использовать внутренний private final Object lock = new Object(), чтобы кто-то не мог заблокировать ваш монитор. Он достигает того же результата без обратной стороны злой внешней блокировки. У вас есть этот дополнительный байт, но он редко имеет значение.

Так что я бы сказал нет, не используйте ключевое слово synchronized в подписи. Вместо этого используйте что-то вроде

public class ThreadedClass implements Runnable{
    private final Object lock = new Object();

    public void run(){
        synchronized(lock) {
            while(true)
                 //do some stuff in a thread
            }
        }
    }
}

Изменить в ответ на комментарий:

Рассмотрим, что делает синхронизация: она предотвращает вход других потоков в тот же блок кода. Итак, представьте, что у вас есть класс, подобный приведенному ниже. Допустим, текущий размер равен 10. Кто-то пытается выполнить добавление, и это приводит к изменению размера резервного массива. Пока они изменяют размер массива, кто-то вызывает makeExactSize(5) в другом потоке. И вдруг вы пытаетесь получить доступ к data[6], и он вылетает из вас. Синхронизация должна предотвратить это. В многопоточных программах просто НУЖНА синхронизация.

class Stack {
    int[] data = new int[10];
    int pos = 0;

    void add(int inc) {
        if(pos == data.length) {
            int[] tmp = new int[pos*2];
            for(int i = 0; i < pos; i++) tmp[i] = data[i];
            data = tmp;
        }
        data[pos++] = inc;
    }

    int remove() {
        return data[pos--];
    }

    void makeExactSize(int size) {
        int[] tmp = new int[size];
        for(int i = 0; i < size; i++) tmp[i] = data[i];
        data = tmp;
    }
}

Почему? Минимальная дополнительная безопасность, и я не вижу правдоподобного сценария, в котором это имело бы значение.

Почему нет? Это не стандартно. Если вы программируете как часть команды, когда какой-то другой участник увидит ваш синхронизированный run, он, вероятно, потратит 30 минут, пытаясь понять, что такого особенного в вашем run или во фреймворке, который вы используете для запуска Runnable.

По моему опыту, бесполезно добавлять ключевое слово «synchronized» в метод run(). Если нам нужно синхронизировать несколько потоков или нам нужна потокобезопасная очередь, мы можем использовать более подходящие компоненты, такие как ConcurrentLinkedQueue.

Ну, теоретически вы могли бы без проблем вызвать сам метод запуска (в конце концов, он общедоступен). Но это не значит, что нужно это делать. Таким образом, в основном нет причин делать это, кроме добавления незначительных накладных расходов в поток, вызывающий run(). Ну, за исключением случаев, когда вы используете экземпляр несколько раз, вызывая new Thread - хотя я а) не уверен, что это законно с потоковым API и б) кажется совершенно бесполезным.

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

Просмотрите комментарии к коду, раскомментируйте и запустите разные блоки, чтобы четко увидеть разницу, синхронизация заметок будет иметь значение, только если используется один и тот же исполняемый экземпляр, если каждый запущенный поток получает новый исполняемый объект, это не будет иметь никакого значения.

class Kat{

public static void main(String... args){
  Thread t1;
  // MyUsualRunnable is usual stuff, only this will allow concurrency
  MyUsualRunnable m0 = new MyUsualRunnable();
  for(int i = 0; i < 5; i++){
  t1 = new Thread(m0);//*imp*  here all threads created are passed the same runnable instance
  t1.start();
  }

  // run() method is synchronized , concurrency killed
  // uncomment below block and run to see the difference

  MySynchRunnable1 m1 = new MySynchRunnable1();
  for(int i = 0; i < 5; i++){
  t1 = new Thread(m1);//*imp*  here all threads created are passed the same runnable instance, m1
  // if new insances of runnable above were created for each loop then synchronizing will have no effect

  t1.start();
}

  // run() method has synchronized block which lock on runnable instance , concurrency killed
  // uncomment below block and run to see the difference
  /*
  MySynchRunnable2 m2 = new MySynchRunnable2();
  for(int i = 0; i < 5; i++){
  // if new insances of runnable above were created for each loop then synchronizing will have no effect
  t1 = new Thread(m2);//*imp*  here all threads created are passed the same runnable instance, m2
  t1.start();
}*/

}
}

class MyUsualRunnable implements Runnable{
  @Override
  public void  run(){
    try {Thread.sleep(1000);} catch (InterruptedException e) {}
}
}

class MySynchRunnable1 implements Runnable{
  // this is implicit synchronization
  //on the runnable instance as the run()
  // method is synchronized
  @Override
  public synchronized void  run(){
    try {Thread.sleep(1000);} catch (InterruptedException e) {}
}
}

class MySynchRunnable2 implements Runnable{
  // this is explicit synchronization
  //on the runnable instance
  //inside the synchronized block
  // MySynchRunnable2 is totally equivalent to MySynchRunnable1
  // usually we never synchronize on this or synchronize the run() method
  @Override
  public void  run(){
    synchronized(this){
    try {Thread.sleep(1000);} catch (InterruptedException e) {}
  }
}
}

на самом деле очень легко обосновать "синхронизировать или не синхронизировать"

если ваш вызов метода может мутировать внутреннее состояние вашего объекта, тогда "синхронизировать", иначе нет необходимости

простой пример

public class Counter {

  private int count = 0; 

  public void incr() {
    count++;
  }

  public int getCount() {
    return count;
  }
}

в приведенном выше примере необходимо синхронизировать incr(), так как он изменит значение count, тогда как синхронизация getCount() не требуется.

однако есть еще один угловой случай, если счетчик равен java.lang.Long, Double, Object, тогда вам нужно объявить как

private volatile long count = 0;

чтобы убедиться, что обновление ref является атомарным

в основном это то, о чем вам нужно думать в 99% случаев при работе с многопоточностью.