Thread sync

Aqui temos um programa com as threads NÃO sincronizadas. O que você queria sincronizar? Não entendi.

class TesteThreads {
    public void teste() throws InterruptedException {
        
         final Thread thr1 = new Thread (new Runnable() {
            public void run() {
                for (int i = 1; i <= 20; ++i) {
                    if (i % 5 == 0)
                        System.out.println (Thread.currentThread().getName() + " - " + i + " - " + (20 - i));
                }
            }
         });
         final Thread thr2 = new Thread (new Runnable() {
            public void run() {
                for (int i = 1; i <= 10; ++i) {
                    if (i % 5 == 0)
                        System.out.println (Thread.currentThread().getName() + " - " + i + " - " + (10 - i));
                }
            }
         });
         thr1.start();
         thr2.start();
         thr1.join();
         thr2.join();
    }
    public static void main (String[] args) throws InterruptedException {
        (new TesteThreads()).teste();
    }
}

também funcionaria dessa forma. Mas estava pensando em criar uma classe que recebe como parametros um valor inicial e outro valor final.

public ClasseCount(int s, int e) {
        this.s = s;
        this.e = e;
    }

    public void run() {
        for (int i = s; i <=e; ++i) {
            if (i % 5 == 0) {
                System.out.println(Thread.currentThread().getName() + " - " + i + " - " + (e - i));
            }
        }
    }

static main ... {

    ClasseCount a;
    ClasseCount b;

    .....

    a.start
    b.start

mais ou menos assim, eu acho, mas aí vem minha dúvida não deveriam ser sincronizadas essas threads?

Pois é, que tipo de sincronização você quer fazer? Você só precisa sincronizar threads se elas acessarem um recurso comum cujo acesso deve ser sincronizado, a fim de que não fique alguma coisa inconsistente ou incoerente. No seu caso, o que o professor lhe pediu?

Escreva um programa concorrente formado por duas threads (?A? e ?B?), que possuem suas ações sincronizadas. Uma das threads conta até 10, e então deve esperar pela outra que conta até 20, e vice-versa. Considere que a execução começa pela thread que conta até 10. A cada 2 valores contados pelas duas threads, o programa deverá escrever uma linha indicando qual thread alcançou a marca e quantos valores ainda faltam ser contabilizados.

Ah, agora sim você está falando direito o que você quer (lição de casa).
No seu caso, como você não pode usar aquelas APIs do java.util.concurrent (não está escrito no enunciado, mas provavelmente o professor não irá aceitar), provavelmente você terá de usar um lock.
No seu caso, você provavelmente terá de usar “wait” e “notify” (argh).

mas se seu fizer mais ou menos assim:

Rode, e veja que não vai funcionar. Por que é que não funciona? Dica: não adianta usar o “synchronized” nesse ponto.

nao entendi. pode me explicar?

Desculpe, não tinha analisado direito seu programa. Como há apenas uma instância da classe Counter, então deve haver a sincronização desejada.
Entretanto, por um motivo um pouco desagradável, você vai ver que às vezes a thread 2 vai começar seu trabalho antes da thread 1, e então a solução que você apresentou não satisfaz plenamente ao proposto por seu professor.
(Não é porque t2.start vem depois de t1.start que a thread 1 vai sempre começar antes da thread 2. Para termos essa sincronização é preciso fazer algo explícito.)

A forma mais estúpida de fazer com que a thread 2 comece depois da thread 1 é fazer com que a thread 1 inicie a thread 2.