de quelle façon est de java.net.Prise de thread-safe?

Sockets sont thread dangereux au niveau du ruisseau. Vous devez fournir la synchronisation. La seule garantie est que vous ne serez pas obtenir des copies des mêmes octets dans différents lire les invocations n'importe simultanéité.

Mais à un Lecteur et, spécialement, l'Écrivain niveau, vous pourriez avoir quelques les problèmes de verrouillage.

De toute façon, vous pouvez gérer les opérations de lecture et écriture avec le support du cours d'eau comme s'ils étaient complètement indépendant des objets (ils sont, la seule chose qu'ils partagent leur lifecyle).

Une fois que vous avez fourni la bonne synchronisation entre les threads de lecture d'une part, et écrivain, fils d'autre part, un certain nombre de lecteurs et d'écrivains va être correct. Cela signifie que, oui, vous pouvez lire sur un fil et d'écrire sur un autre (en fait, c'est très fréquent), et vous n'avez pas à arrêter de lire pendant l'écriture.

Un dernier conseil: toutes les opérations impliquant des threads délai associé, assurez-vous de gérer les délais d'attente correctement.

OriginalL'auteur mschonaker

Java java.net.Socket n'est en fait pas thread-safe: Ouvrez le support de la source, et de regarder l' (disons) connected membre du terrain et la façon dont il est utilisé. Vous verrez que c'est pas volatile, lu et mis à jour sans synchrinization. Cela indique que la classe Socket n'est pas conçu pour être utilisé par plusieurs threads. Cependant, il existe certaines serrures et de synchronisation, il n'est pas cohérent.`

Je recommande de ne pas le faire. Finalement, utiliser des tampons(nio), et ne socket lectures/écritures dans un thread

Pour plus de détails rendez-vous sur la discussionv

OriginalL'auteur Op De Cirkel

C'est de cette façon socketWrite en code natif, donc ce n'est pas thread-safe à partir du code

JNIEXPORT void JNICALL
Java_java_net_SocketOutputStream_socketWrite0(JNIEnv *env, jobject this,
jobject fdObj,
jbyteArray data,
jint off, jint len) {
char *bufP;
char BUF[MAX_BUFFER_LEN];
int buflen;
int fd;
if (IS_NULL(fdObj)) {
JNU_ThrowByName(env, "java/net/SocketException", "Socket closed");
return;
} else {
fd = (*env)->GetIntField(env, fdObj, IO_fd_fdID);
/* Bug 4086704 - If the Socket associated with this file descriptor
* was closed (sysCloseFD), the the file descriptor is set to -1.
*/
if (fd == -1) {
JNU_ThrowByName(env, "java/net/SocketException", "Socket closed");
return;
}
}
if (len <= MAX_BUFFER_LEN) {
bufP = BUF;
buflen = MAX_BUFFER_LEN;
} else {
buflen = min(MAX_HEAP_BUFFER_LEN, len);
bufP = (char *)malloc((size_t)buflen);
/* if heap exhausted resort to stack buffer */
if (bufP == NULL) {
bufP = BUF;
buflen = MAX_BUFFER_LEN;
}
}
while(len > 0) {
int loff = 0;
int chunkLen = min(buflen, len);
int llen = chunkLen;
(*env)->GetByteArrayRegion(env, data, off, chunkLen, (jbyte *)bufP);
while(llen > 0) {
int n = NET_Send(fd, bufP + loff, llen, 0);
if (n > 0) {
llen -= n;
loff += n;
continue;
}
if (n == JVM_IO_INTR) {
JNU_ThrowByName(env, "java/io/InterruptedIOException", 0);
} else {
if (errno == ECONNRESET) {
JNU_ThrowByName(env, "sun/net/ConnectionResetException",
"Connection reset");
} else {
NET_ThrowByNameWithLastError(env, "java/net/SocketException",
"Write failed");
}
}
if (bufP != BUF) {
free(bufP);
}
return;
}
len -= chunkLen;
off += chunkLen;
}
if (bufP != BUF) {
free(bufP);
}
}

OriginalL'auteur Xiaolong Jiang