整改

src/Client.kt

@@ -1,75 +1,67 @@
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.launch
+import kotlinx.coroutines.runBlocking
 import java.io.IOException
 import java.io.InputStream
 import java.io.OutputStream
 import java.net.Socket
 import javax.sound.sampled.AudioFormat
 import javax.sound.sampled.AudioSystem
-import javax.sound.sampled.SourceDataLine
-import javax.sound.sampled.TargetDataLine
 
-object Client {
 var `in`: InputStream? = null
 var out: OutputStream? = null
-    var sourceDataLine: SourceDataLine? = null
+var sample = FloatArray(BUFFER_SIZE)
-    var targetDataLine: TargetDataLine? = null
+var bufferOut = ByteArray(sample.size * 2)
-    var bufferOut: ByteArray
+var bufferIn = ByteArray(sample.size * 2)
-    var bufferIn: ByteArray
-    var sample: FloatArray
 var SAMPLE_RATE: Int = 48000
 var CHANNELS: Int = 1
 var format: AudioFormat = AudioConvert.getAudioFormat(SAMPLE_RATE, CHANNELS)
 var socket: Socket? = null
+var targetDataLine = AudioSystem.getTargetDataLine(format)
+var sourceDataLine = AudioSystem.getSourceDataLine(format)
 
-    @Throws(Exception::class)
+object Client {
     @JvmStatic
     fun main(args: Array<String>) {
+        mainClient()
+    }
+}
+
+fun mainClient() = runBlocking {
     socket = Socket("127.0.0.1", 7860)
     `in` = socket!!.getInputStream()
     out = socket!!.getOutputStream()
-        sample = FloatArray(Server.BUFFER_SIZE)
-        bufferIn = ByteArray(sample.size * 2)
-        bufferOut = ByteArray(sample.size * 2)
 
-        targetDataLine = AudioSystem.getTargetDataLine(format)
     targetDataLine.open(format, bufferIn.size)
     targetDataLine.start()
 
-
-        sourceDataLine = AudioSystem.getSourceDataLine(format)
     sourceDataLine.open(format, bufferIn.size)
     sourceDataLine.start()
 
-
+    launch(Dispatchers.Default) {
-        Thread {
         while (true) {
             //Arrays.fill(bufferOut, (byte) 0);
             targetDataLine.read(bufferOut, 0, bufferOut.size)
             try {
-                    out.write(bufferOut, 0, bufferOut.size)
+                out!!.write(bufferOut, 0, bufferOut.size)
-                    out.flush()
+                out!!.flush()
             } catch (e: Exception) {
                 e.printStackTrace()
                 System.exit(0)
             }
         }
-        }.start()
+    }
 
-
+    launch {
-        Thread {
         while (true) {
             try {
-                    `in`.read(bufferIn, 0, bufferIn.size)
+                `in`!!.read(bufferIn, 0, bufferIn.size)
                 sourceDataLine.write(bufferIn, 0, bufferIn.size)
             } catch (e: IOException) {
                 e.printStackTrace()
                 System.exit(0)
             }
         }
-        }.start()
-
-
-        /*
-        audioOutputLine.setAudioProcessor();
-        audioOutputLine.open(48000, 1, 20480);*/
     }
+
 }

src/Server.kt

@@ -1,3 +1,7 @@
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.launch
+import kotlinx.coroutines.runBlocking
 import java.io.IOException
 import java.io.InputStream
 import java.io.OutputStream
@@ -6,18 +10,14 @@ import java.net.Socket
 import java.util.*
 import java.util.concurrent.CopyOnWriteArrayList
 
-object Server {
 var clientAudios: MutableList<ClientAudio> = CopyOnWriteArrayList()
-    @kotlin.jvm.JvmField
+var BUFFER_SIZE: Int = 2048 * CHANNELS
-    var BUFFER_SIZE: Int = 2048 * Client.CHANNELS
+
-    var mixSample: FloatArray = FloatArray(BUFFER_SIZE)
 var buffer: ByteArray = ByteArray(BUFFER_SIZE * 2)
 
-    @kotlin.Throws(Exception::class)
+fun main() = runBlocking {
-    @kotlin.jvm.JvmStatic
-    fun main(args: Array<String>) {
     //混音
-        Thread {
+    launch(Dispatchers.Default) {
         while (true) {
             for (client in clientAudios) {
                 if (!client.isConnected) {
@@ -25,24 +25,21 @@ object Server {
                     println("现在是： " + clientAudios)
                     continue
                 }
-
                 client.read()
             }
 
-
             for (client in clientAudios) {
-                    Arrays.fill(mixSample, 0f)
+                launch(Dispatchers.Default) {
                     for (audio in clientAudios) {
-                        //if (audio != client)
+                        if (audio != client)
-                        audio.mix(mixSample)
+                            audio.mix(client.mixSample)
                     }
-                    AudioConvert.convertFloatToShortByte(mixSample, buffer)
+                    AudioConvert.convertFloatToShortByte(client.mixSample, buffer)
                     client.send(buffer)
                 }
-
-                //System.out.println("混音");
             }
-        }.start()
+        }
+    }
 
     val sever = ServerSocket(7860)
     while (true) {
@@ -57,6 +54,7 @@ object Server {
     var out: OutputStream? = null
     var buffer: ByteArray = ByteArray(BUFFER_SIZE * 2)
     var sample: FloatArray = FloatArray(BUFFER_SIZE)
+    var mixSample: FloatArray = FloatArray(BUFFER_SIZE)
 
     init {
         try {
@@ -82,6 +80,7 @@ object Server {
         try {
             `in`!!.read(buffer)
             AudioConvert.convertShortByteToFloat(buffer, sample)
+            Arrays.fill(mixSample, 0f)
         } catch (e: IOException) {
             //throw new RuntimeException(e);
         }
@@ -93,4 +92,3 @@ object Server {
         }
     }
 }
-}