Si bien se puede leer directamente en una estructura en C++ igual que en C, hay que tener cuidado de no tener campos que sean clases dentro, y que no haya punteros tampoco.
¿Qué tiene "UnaClase"? Si tuviera por ejemplo una string, podría ser un problema.

Hay montones de compañías con términos del estilo.
No es nada de lo que tener miedo. Big Data, es parte del futuro.
No se queja tanto la gente cuando Google les muestra lo que están buscando. Anda, en tu idioma además.

La pena es que el mundo avance y la gente se siga quedando atrás porque "Dios mio, me están espiando". Aunque es una frase muy típica, no es menos cierta: A nadie le importa lo que hagas por internet.

Siempre sacándole punta a todo e.e

Las clases del paquete atomic son precisamente thread-safe y lock-free. Son una optimización al uso de locks, y su uso es precisamente este.

No sé que pretendías ver en tu ejemplo, pero el resultado es el esperado: La variable ha sido incrementada 10 veces, por tanto, es 10, punto.

Puedes verificarlo si quieres:

import java.util.Objects;
import java.util.concurrent.*;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.logging.Logger;
import java.util.stream.IntStream;
 
public class UsoSynchronized {
 
    private static final Logger LOGGER = Logger.getLogger(UsoSynchronized.class.getSimpleName());
    private ExecutorService executors = null;
    private AtomicInteger atomicInteger = new AtomicInteger(0);
 
    public UsoSynchronized() {
        try {
            executors = Executors.newFixedThreadPool(20);
            IntStream.rangeClosed(1,10)
                    .forEach(e -> {
                        executors.submit(()-> withAtomicInteger());
                    });
 
        } finally {
            if(Objects.nonNull(executors)) {
                executors.shutdown();
 
                try {
                    executors.awaitTermination(1, TimeUnit.DAYS);
                } catch (InterruptedException exc) {
                }
            }
        }
 
        LOGGER.info("Final: "+ atomicInteger.get());
    }
 
    public void withAtomicInteger() {
        LOGGER.info(""+ atomicInteger.incrementAndGet());
    }
 
    public static void main(String... haga) {
        new UsoSynchronized();
    }
}

Verás un 10 en Final, es lo esperado, y verás los números del 1 al 10 antes que él.

Si tú te refieres al orden, evidentemente el orden no es una necesidad en este caso, y como tal, no se mantiene.

La razón de que actualmente no te funcione es que los tipos primitivos como int se copian cuando los pasas como parámetro. Al copiarse, es otro objeto diferente, y aunque lo modifiques, el original se queda igual. Para pasar objetos, tendrías que utilizar clases en vez de tipos primitivos.

Tendrías que meter la variable dentro de una clase y compartir un objeto de esa clase con las 2 que lo van a modificar. Otra opción es tenerlo como variable static y que accedan directamente a ella.

Dado que el acceso concurrente te acabaría dando problemas, puedes usar la clase AtomicInteger que sirve precisamente para eso: Modificar un int desde varios hilos. Podrías crearla en el main, y pasárselo al constructor de los otros 2 como haces ahora.

refuncion(&pnum);

Con eso estás pasando como parámetro la dirección del puntero, es decir, un int** (dirección de una dirección).
Sin embargo, en la función esperas un int&. El uso de "&" antes de una variable es diferente a su utilidad después de un tipo. Para que esto compilase, deberías pasarle a la función "*pnum" (es decir, un int). "int&" es una referencia a un int, es decir, lo que le hagas al parámetro "ref" será como hacérselo a "*pnum".

Aunque este código compile, habrá un error, y es que al hacer "*pnum = 5" estás diciendo que "la variable a la que apunta "pnum" se establecerá a 5. El problema, es que "pnum" no apunta a ninguna variable.

Puedes hacer este cambio:

int num = 5;
int* pnum = #
// ...

Lo que estás viendo probablemente sea que el proceso padre ha terminado (ha llegado al return), pero el proceso hijo aun no ha mostrado por pantalla su linea.

Cuando el proceso padre termina, la consola lo detecta, y te vuelve a mostrar la línea para escribir comandos.
Luego, el proceso hijo muestra por consola su mensaje.

Al trabajar con procesos, es importante controlar el orden en el que terminan los hilos. Rara vez querrás que el proceso padre termine antes que los procesos hijos, con lo cual habría que esperar en el proceso padre a que los hijos terminen.

Para ello, entre las varias opciones que hay: http://man7.org/linux/man-pages/man2/wait.2.html

Puedes. Puedes declarar un arreglo de cualquier tipo (incluyendo un "puntero a X" como un tipo).

int* integers; // Array de enteros
int** integerPointers; // Array de punteros a enteros (o array de arrays, según como lo inicialices)

No sé si responde la duda; hablo muy por encima... Si tienes alguna caso más particular, se puede mirar

Ya casi no se me ve el pelo por aquí pero...
Feliz navidad a todos

Puedes probar Minidosis: http://www.minidosis.org/
De ese profesor solo viera sus vídeos, pero ahora tiene bastante más material en la web.