1
public class InetAddressDemo {
2
    public static void main(String[] args) throws UnknownHostException {
3
    // InetAddress address = InetAddress.getByName("itheima");
4
        InetAddress address = InetAddress.getByName("192.168.1.66");
5

6
        // public String getHostName()：获取此IP地址的主机名
7
        String name = address.getHostName();
8
        // public String getHostAddress()：返回文本显示中的IP地址字符串
9
        String ip = address.getHostAddress();
10

11
        System.out.println("主机名：" + name);
12
        System.out.println("IP地址：" + ip);
13
    }
14
}

1
public class SendDemo {
2
    public static void main(String[] args) throws IOException {
3
        // 创建发送端的Socket对象(DatagramSocket)
4
        // DatagramSocket() 构造数据报套接字并将其绑定到本地主机上的任何可用端口
5
        DatagramSocket ds = new DatagramSocket();
6

7
        // 创建数据，并把数据打包
8
        // DatagramPacket(byte[] buf, int length, InetAddress address, int port)
9
        // 构造一个数据包，发送长度为 length的数据包到指定主机上的指定端口号。
10
        byte[] bys = "hello,udp,我来了".getBytes();
11

12
        DatagramPacket dp = new DatagramPacket(bys,bys.length,InetAddress.getByName("127.0.0.1"),10086);
13

14
        // 调用DatagramSocket对象的方法发送数据
15
        // void send(DatagramPacket p) 从此套接字发送数据报包
16
        ds.send(dp);
17

18
        // 关闭发送端
19
        // void close() 关闭此数据报套接字
20
        ds.close();
21
    }
22
}

1
public class ReceiveDemo {
2
    public static void main(String[] args) throws IOException {
3
        // 创建接收端的Socket对象(DatagramSocket)
4
        DatagramSocket ds = new DatagramSocket(12345);
5

6
        // 创建一个数据包，用于接收数据
7
        byte[] bys = new byte[1024];
8
        DatagramPacket dp = new DatagramPacket(bys, bys.length);
9

10
        // 调用DatagramSocket对象的方法接收数据
11
        ds.receive(dp);
12

13
        // 解析数据包，并把数据在控制台显示
14
        System.out.println("数据是：" + new String(dp.getData(), 0,                                             dp.getLength()));
15
        }
16
    }
17
}

1
/*
2
 UDP发送数据：
3
 数据来自于键盘录入，直到输入的数据是886，发送数据结束
4
*/
5
public class SendDemo {
6
    public static void main(String[] args) throws IOException {
7
        // 创建发送端的Socket对象(DatagramSocket)
8
        DatagramSocket ds = new DatagramSocket();
9
        // 键盘录入数据
10
        Scanner sc = new Scanner(System.in);
11
        while (true) {
12
            String s = sc.nextLine();
13
            //输入的数据是886，发送数据结束
14
            if ("886".equals(s)) {
15
                break;
16
            }
17
            // 创建数据，并把数据打包
18
            byte[] bys = s.getBytes();
19
            DatagramPacket dp = new DatagramPacket(bys, bys.length, InetAddress.getByName("192.168.1.66"), 12345);
20

21
            // 调用DatagramSocket对象的方法发送数据
22
            ds.send(dp);
23
        }
24
        // 关闭发送端
25
        ds.close();
26
    }
27
}
28

29
/*
30
 UDP接收数据：
31
 因为接收端不知道发送端什么时候停止发送，故采用死循环接收
32
*/
33
public class ReceiveDemo {
34
    public static void main(String[] args) throws IOException {
35
        // 创建接收端的Socket对象(DatagramSocket)
36
        DatagramSocket ds = new DatagramSocket(12345);
37
        while (true) {
38
            // 创建一个数据包，用于接收数据
39
            byte[] bys = new byte[1024];
40
            DatagramPacket dp = new DatagramPacket(bys, bys.length);
41
            // 调用DatagramSocket对象的方法接收数据
42
            ds.receive(dp);
43
            // 解析数据包，并把数据在控制台显示
44
            System.out.println("数据是：" + new String(dp.getData(), 0, dp.getLength()));
45
        }
46
        // 关闭接收端
47
        ds.close();
48
    }
49
}

1
// 发送端
2
public class ClinetDemo {
3
    public static void main(String[] args) throws IOException {
4
        // 1.创建发送端的Socket对象(DatagramSocket)
5
        DatagramSocket ds = new DatagramSocket();
6
        String s = "hello 组播";
7
        byte[] bytes = s.getBytes();
8
        InetAddress address = InetAddress.getByName("224.0.1.0");
9
        int port = 10000;
10
        // 2.创建数据，并把数据打包(DatagramPacket)
11
        DatagramPacket dp = new DatagramPacket(bytes,bytes.length,address,port);
12
        // 3.调用DatagramSocket对象的方法发送数据(在单播中,这里是发给指定IP的电脑但是在组播当中,这里是发给组播地址)
13
        ds.send(dp);
14
        // 4.释放资源
15
        ds.close();
16
    }
17
}
18
// 接收端
19
public class ServerDemo {
20
    public static void main(String[] args) throws IOException {
21
        // 1.创建接收端Socket对象(MulticastSocket)
22
        MulticastSocket ms = new MulticastSocket(10000);
23
        // 2.创建一个箱子,用于接收数据
24
        DatagramPacket dp = new DatagramPacket(new byte[1024],1024);
25
        // 3.把当前计算机绑定一个组播地址,表示添加到这一组中.
26
        ms.joinGroup(InetAddress.getByName("224.0.1.0"));
27
        // 4.将数据接收到箱子中
28
        ms.receive(dp);
29
        // 5.解析数据包,并打印数据
30
        byte[] data = dp.getData();
31
        int length = dp.getLength();
32
        System.out.println(new String(data,0,length));
33
        // 6.释放资源
34
        ms.close();
35
    }
36
}

1
// 发送端
2
public class ClientDemo {
3
    public static void main(String[] args) throws IOException {
4
        // 1.创建发送端Socket对象(DatagramSocket)
5
        DatagramSocket ds = new DatagramSocket();
6
    // 2.创建存储数据的箱子,将广播地址封装进去
7
        String s = "广播 hello";
8
        byte[] bytes = s.getBytes();
9
        InetAddress address = InetAddress.getByName("255.255.255.255");
10
        int port = 10000;
11
        DatagramPacket dp = new DatagramPacket(bytes,bytes.length,address,port);
12
    // 3.发送数据
13
        ds.send(dp);
14
    // 4.释放资源
15
        ds.close();
16
    }
17
}
18

19
// 接收端
20
public class ServerDemo {
21
    public static void main(String[] args) throws IOException {
22
        // 1.创建接收端的Socket对象(DatagramSocket)
23
        DatagramSocket ds = new DatagramSocket(10000);
24
        // 2.创建一个数据包，用于接收数据
25
        DatagramPacket dp = new DatagramPacket(new byte[1024],1024);
26
        // 3.调用DatagramSocket对象的方法接收数据
27
        ds.receive(dp);
28
        // 4.解析数据包，并把数据在控制台显示
29
        byte[] data = dp.getData();
30
        int length = dp.getLength();
31
        System.out.println(new String(data,0,length));
32
        // 5.关闭接收端
33
        ds.close();
34
    }
35
}

1
public class Client {
2
    public static void main(String[] args) throws IOException {
3
        // TCP协议，发送数据
4

5
        // 1.创建Socket对象
6
        // 细节：在创建对象的同时会连接服务端
7
        // 如果连接不上，代码会报错
8
        Socket socket = new Socket("127.0.0.1",10000);
9

10
        // 2.可以从连接通道中获取输出流
11
        OutputStream os = socket.getOutputStream();
12
        // 写出数据
13
        os.write("aaa".getBytes());
14

15
        // 3.释放资源
16
        os.close();
17
        socket.close();
18
    }
19
}

1
public class Server {
2
    public static void main(String[] args) throws IOException {
3
        // TCP协议，接收数据
4

5
        // 1.创建对象ServerSocker
6
        ServerSocket ss = new ServerSocket(10000);
7

8
        // 2.监听客户端的链接
9
        Socket socket = ss.accept();
10

11
        // 3.从连接通道中获取输入流读取数据
12
        InputStream is = socket.getInputStream();
13
        int b;
14
        while ((b = is.read()) != -1){
15
            System.out.println((char) b);
16
        }
17

18
        // 4.释放资源
19
        socket.close();
20
        ss.close();
21
    }
22
}

1
public class Client {
2
    public static void main(String[] args) throws IOException {
3
        // TCP协议，发送数据
4

5
        // 1.创建Socket对象
6
        // 细节：在创建对象的同时会连接服务端
7
        // 如果连接不上，代码会报错
8
        Socket socket = new Socket("127.0.0.1",10000);
9

10

11
        // 2.可以从连接通道中获取输出流
12
        OutputStream os = socket.getOutputStream();
13
        // 写出数据
14
        os.write("你好你好".getBytes());//12字节
15

16
        // 3.释放资源
17
        os.close();
18
        socket.close();
19

20
    }
21
}

1
public class Server {
2
    public static void main(String[] args) throws IOException {
3
        // TCP协议，接收数据
4

5
        // 1.创建对象ServerSocker
6
        ServerSocket ss = new ServerSocket(10000);
7

8
        // 2.监听客户端的链接
9
        Socket socket = ss.accept();
10

11
        // 3.从连接通道中获取输入流读取数据
12
        InputStream is = socket.getInputStream();
13
        InputStreamReader isr = new InputStreamReader(is);
14
        BufferedReader br = new BufferedReader(isr);
15

16
        // BufferedReader br = new BufferedReader(new InputStreamReader(socket.getInputStream()));
17

18
        int b;
19
        while ((b = br.read()) != -1){
20
            System.out.print((char) b);
21
        }
22

23
        // 4.释放资源
24
        socket.close();
25
        ss.close();
26

27
    }
28
}

1
public class Client {
2
    public static void main(String[] args) throws IOException {
3
        //客户端：多次发送数据
4
        //服务器：接收多次接收数据，并打印
5

6
        //1. 创建Socket对象并连接服务端
7
        Socket socket = new Socket("127.0.0.1",10000);
8

9
        //2.写出数据
10
        Scanner sc = new Scanner(System.in);
11
        OutputStream os = socket.getOutputStream();
12

13
        while (true) {
14
            System.out.println("请输入您要发送的信息");
15
            String str = sc.nextLine();
16
            if("886".equals(str)){
17
                break;
18
            }
19
            os.write(str.getBytes());
20
        }
21
        //3.释放资源
22
        socket.close();
23
    }
24
}

1
public class Server {
2
    public static void main(String[] args) throws IOException {
3
        //客户端：多次发送数据
4
        //服务器：接收多次接收数据，并打印
5

6
        //1.创建对象绑定10000端口
7
        ServerSocket ss = new ServerSocket(10000);
8

9
        //2.等待客户端来连接
10
        Socket socket = ss.accept();
11

12
        //3.读取数据
13
        InputStreamReader isr = new InputStreamReader(socket.getInputStream());
14
        int b;
15
        while ((b = isr.read()) != -1){
16
            System.out.print((char)b);
17
        }
18

19
        //4.释放资源
20
        socket.close();
21
        ss.close();
22
    }
23
}

1
// 客户端
2
public class ClientDemo {
3
    public static void main(String[] args) throws IOException {
4
        Socket socket = new Socket("127.0.0.1",10000);
5

6
        OutputStream os = socket.getOutputStream();
7
        os.write("hello".getBytes());
8
       // os.close();如果在这里关流,会导致整个socket都无法使用
9
        socket.shutdownOutput();//仅仅关闭输出流.并写一个结束标记,对socket没有任何影响
10

11
        BufferedReader br = new BufferedReader(new InputStreamReader(socket.getInputStream()));
12
        String line;
13
        while((line = br.readLine())!=null){
14
            System.out.println(line);
15
        }
16
        br.close();
17
        os.close();
18
        socket.close();
19
    }
20
}
21
// 服务器
22
public class ServerDemo {
23
    public static void main(String[] args) throws IOException {
24
        ServerSocket ss = new ServerSocket(10000);
25

26
        Socket accept = ss.accept();
27

28
        InputStream is = accept.getInputStream();
29
        int b;
30
        while((b = is.read())!=-1){
31
            System.out.println((char) b);
32
        }
33

34
        System.out.println("看看我执行了吗?");
35

36
        BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(accept.getOutputStream()));
37
        bw.write("你谁啊?");
38
        bw.newLine();
39
        bw.flush();
40

41
        bw.close();
42
        is.close();
43
        accept.close();
44
        ss.close();
45
    }
46
}

1
public class Client {
2
    public static void main(String[] args) throws IOException {
3
        // 客户端：将本地文件上传到服务器。接收服务器的反馈。
4
        // 服务器：接收客户端上传的文件，上传完毕之后给出反馈。
5

6
        // 1. 创建Socket对象，并连接服务器
7
        Socket socket = new Socket("127.0.0.1",10000);
8

9
        // 2.读取本地文件中的数据，并写到服务器当中
10
        BufferedInputStream bis = new BufferedInputStream(new FileInputStream("mysocketnet\\clientdir\\a.jpg"));
11
        BufferedOutputStream bos = new BufferedOutputStream(socket.getOutputStream());
12
        byte[] bytes = new byte[1024];
13
        int len;
14
        while ((len = bis.read(bytes)) != -1){
15
            bos.write(bytes,0,len);
16
        }
17

18
        // 往服务器写出结束标记
19
        socket.shutdownOutput();
20

21

22
        // 3.接收服务器的回写数据
23
        BufferedReader br = new BufferedReader(new InputStreamReader(socket.getInputStream()));
24
        String line = br.readLine();
25
        System.out.println(line);
26

27

28
        // 4.释放资源
29
        socket.close();
30

31
    }
32
}

1
public class Server {
2
    public static void main(String[] args) throws IOException {
3
        //客户端：将本地文件上传到服务器。接收服务器的反馈。
4
        //服务器：接收客户端上传的文件，上传完毕之后给出反馈。
5

6
        // 1.创建对象并绑定端口
7
        ServerSocket ss = new ServerSocket(10000);
8

9
        // 2.等待客户端来连接
10
        Socket socket = ss.accept();
11

12
        // 3.读取数据并保存到本地文件中
13
        BufferedInputStream bis = new BufferedInputStream(socket.getInputStream());
14
        BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("mysocketnet\\serverdir\\a.jpg"));
15
        int len;
16
        byte[] bytes = new byte[1024];
17
        while ((len = bis.read(bytes)) != -1){
18
            bos.write(bytes,0,len);
19
        }
20
        bos.close();
21
        // 4.回写数据
22
        BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(socket.getOutputStream()));
23
        bw.write("上传成功");
24
        bw.newLine();
25
        bw.flush();
26

27
        // 5.释放资源
28
        socket.close();
29
        ss.close();
30
    }
31
}

1
public class UUIDTest {
2
  public static void main(String[] args) {
3
      String str = UUID.randomUUID().toString().replace("-", "");
4
        System.out.println(str);//9f15b8c356c54f55bfcb0ee3023fce8a
5
    }
6
}

1
public class Client {
2
    public static void main(String[] args) throws IOException {
3
        // 客户端：将本地文件上传到服务器。接收服务器的反馈。
4
        // 服务器：接收客户端上传的文件，上传完毕之后给出反馈。
5

6
        // 1. 创建Socket对象，并连接服务器
7
        Socket socket = new Socket("127.0.0.1",10000);
8

9
        // 2.读取本地文件中的数据，并写到服务器当中
10
        BufferedInputStream bis = new BufferedInputStream(new FileInputStream("mysocketnet\\clientdir\\a.jpg"));
11
        BufferedOutputStream bos = new BufferedOutputStream(socket.getOutputStream());
12
        byte[] bytes = new byte[1024];
13
        int len;
14
        while ((len = bis.read(bytes)) != -1){
15
            bos.write(bytes,0,len);
16
        }
17

18
        // 往服务器写出结束标记
19
        socket.shutdownOutput();
20

21
        // 3.接收服务器的回写数据
22
        BufferedReader br = new BufferedReader(new InputStreamReader(socket.getInputStream()));
23
        String line = br.readLine();
24
        System.out.println(line);
25

26
        // 4.释放资源
27
        socket.close();
28

29
    }
30
}

1
public class Server {
2
    public static void main(String[] args) throws IOException {
3
        // 客户端：将本地文件上传到服务器。接收服务器的反馈。
4
        // 服务器：接收客户端上传的文件，上传完毕之后给出反馈。
5

6
        // 1.创建对象并绑定端口
7
        ServerSocket ss = new ServerSocket(10000);
8

9
        // 2.等待客户端来连接
10
        Socket socket = ss.accept();
11

12
        // 3.读取数据并保存到本地文件中
13
        BufferedInputStream bis = new BufferedInputStream(socket.getInputStream());
14
        String name = UUID.randomUUID().toString().replace("-", "");
15
        BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("mysocketnet\\serverdir\\" + name + ".jpg"));
16
        int len;
17
        byte[] bytes = new byte[1024];
18
        while ((len = bis.read(bytes)) != -1) {
19
            bos.write(bytes, 0, len);
20
        }
21
        bos.close();
22
        // 4.回写数据
23
        BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(socket.getOutputStream()));
24
        bw.write("上传成功");
25
        bw.newLine();
26
        bw.flush();
27

28
        // 5.释放资源
29
        socket.close();
30
        ss.close();
31
    }
32
}

1
public class Client {
2
    public static void main(String[] args) throws IOException {
3
        // 客户端：将本地文件上传到服务器。接收服务器的反馈。
4
        // 服务器：接收客户端上传的文件，上传完毕之后给出反馈。
5

6

7
        // 1.创建Socket对象，并连接服务器
8
        Socket socket = new Socket("127.0.0.1",10000);
9

10
        // 2.读取本地文件中的数据，并写到服务器当中
11
        BufferedInputStream bis = new BufferedInputStream(new FileInputStream("mysocketnet\\clientdir\\a.jpg"));
12
        BufferedOutputStream bos = new BufferedOutputStream(socket.getOutputStream());
13
        byte[] bytes = new byte[1024];
14
        int len;
15
        while ((len = bis.read(bytes)) != -1){
16
            bos.write(bytes,0,len);
17
        }
18

19
        // 往服务器写出结束标记
20
        socket.shutdownOutput();
21

22

23
        // 3.接收服务器的回写数据
24
        BufferedReader br = new BufferedReader(new InputStreamReader(socket.getInputStream()));
25
        String line = br.readLine();
26
        System.out.println(line);
27

28

29
        // 4.释放资源
30
        socket.close();
31

32
    }
33
}

1
public class Server {
2
    public static void main(String[] args) throws IOException {
3
        // 客户端：将本地文件上传到服务器。接收服务器的反馈。
4
        // 服务器：接收客户端上传的文件，上传完毕之后给出反馈。
5

6
        // 1.创建对象并绑定端口
7
        ServerSocket ss = new ServerSocket(10000);
8

9
        while (true) {
10
            // 2.等待客户端来连接
11
            Socket socket = ss.accept();
12

13
            // 开启一条线程
14
            // 一个用户就对应服务端的一条线程
15
            new Thread(new MyRunnable(socket)).start();
16
        }
17

18
    }
19
}
20

21
public class MyRunnable implements Runnable{
22

23
    Socket socket;
24

25
    public MyRunnable(Socket socket){
26
        this.socket = socket;
27
    }
28

29
    @Override
30
    public void run() {
31
        try {
32
            // 3.读取数据并保存到本地文件中
33
            BufferedInputStream bis = new BufferedInputStream(socket.getInputStream());
34
            String name = UUID.randomUUID().toString().replace("-", "");
35
            BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("mysocketnet\\serverdir\\" + name + ".jpg"));
36
            int len;
37
            byte[] bytes = new byte[1024];
38
            while ((len = bis.read(bytes)) != -1) {
39
                bos.write(bytes, 0, len);
40
            }
41
            bos.close();
42
            // 4.回写数据
43
            BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(socket.getOutputStream()));
44
            bw.write("上传成功");
45
            bw.newLine();
46
            bw.flush();
47
        } catch (IOException e) {
48
            e.printStackTrace();
49
        } finally {
50
            // 5.释放资源
51
           if(socket != null){
52
               try {
53
                   socket.close();
54
               } catch (IOException e) {
55
                   e.printStackTrace();
56
               }
57
           }
58
        }
59
    }
60
}

1
public class Client {
2
    public static void main(String[] args) throws IOException {
3
        // 客户端：将本地文件上传到服务器。接收服务器的反馈。
4
        // 服务器：接收客户端上传的文件，上传完毕之后给出反馈。
5

6
        // 1. 创建Socket对象，并连接服务器
7
        Socket socket = new Socket("127.0.0.1",10000);
8

9
        // 2.读取本地文件中的数据，并写到服务器当中
10
        BufferedInputStream bis = new BufferedInputStream(new FileInputStream("mysocketnet\\clientdir\\a.jpg"));
11
        BufferedOutputStream bos = new BufferedOutputStream(socket.getOutputStream());
12
        byte[] bytes = new byte[1024];
13
        int len;
14
        while ((len = bis.read(bytes)) != -1){
15
            bos.write(bytes,0,len);
16
        }
17

18
        // 往服务器写出结束标记
19
        socket.shutdownOutput();
20

21
        // 3.接收服务器的回写数据
22
        BufferedReader br = new BufferedReader(new InputStreamReader(socket.getInputStream()));
23
        String line = br.readLine();
24
        System.out.println(line);
25

26
        // 4.释放资源
27
        socket.close();
28

29
    }
30
}

1
public class Server {
2
    public static void main(String[] args) throws IOException {
3
        // 客户端：将本地文件上传到服务器。接收服务器的反馈。
4
        // 服务器：接收客户端上传的文件，上传完毕之后给出反馈。
5

6
        //创建线程池对象
7
        ThreadPoolExecutor pool = new ThreadPoolExecutor(
8
                3,// 核心线程数量
9
                16,// 线程池总大小
10
                60,// 空闲时间
11
                TimeUnit.SECONDS,// 空闲时间（单位）
12
                new ArrayBlockingQueue<>(2),// 队列
13
                Executors.defaultThreadFactory(),// 线程工厂，让线程池如何创建线程对象
14
                new ThreadPoolExecutor.AbortPolicy()// 阻塞队列
15
        );
16

17
        // 1.创建对象并绑定端口
18
        ServerSocket ss = new ServerSocket(10000);
19

20
        while (true) {
21
            // 2.等待客户端来连接
22
            Socket socket = ss.accept();
23

24
            // 开启一条线程
25
            // 一个用户就对应服务端的一条线程
26
            // new Thread(new MyRunnable(socket)).start();
27
            pool.submit(new MyRunnable(socket));
28
        }
29

30
    }
31
}

1
public class MyRunnable implements Runnable{
2

3
    Socket socket;
4

5
    public MyRunnable(Socket socket){
6
        this.socket = socket;
7
    }
8

9
    @Override
10
    public void run() {
11
        try {
12
            // 3.读取数据并保存到本地文件中
13
            BufferedInputStream bis = new BufferedInputStream(socket.getInputStream());
14
            String name = UUID.randomUUID().toString().replace("-", "");
15
            BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("mysocketnet\\serverdir\\" + name + ".jpg"));
16
            int len;
17
            byte[] bytes = new byte[1024];
18
            while ((len = bis.read(bytes)) != -1) {
19
                bos.write(bytes, 0, len);
20
            }
21
            bos.close();
22
            // 4.回写数据
23
            BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(socket.getOutputStream()));
24
            bw.write("上传成功");
25
            bw.newLine();
26
            bw.flush();
27
        } catch (IOException e) {
28
            e.printStackTrace();
29
        } finally {
30
            // 5.释放资源
31
           if(socket != null){
32
               try {
33
                   socket.close();
34
               } catch (IOException e) {
35
                   e.printStackTrace();
36
               }
37
           }
38
        }
39
    }
40
}

1
public class MyThread extends Thread {
2
    @Override
3
    public void run() {
4
        for (int i = 0; i < 100; i++) {
5
            System.out.println(i);
6
        }
7
    }
8
}
9

10
public class MyThreadDemo {
11
    public static void main(String[] args) {
12
        MyThread my1 = new MyThread();
13
        MyThread my2 = new MyThread();
14

15
// my1.run();
16
// my2.run();
17
// void start() 导致此线程开始执行; Java虚拟机调用此线程的run方法
18
my1.start();
19
        my2.start();
20
    }
21
}

1
public class MyRunnable implements Runnable {
2
    @Override
3
    public void run() {
4
        for(int i=0; i<100; i++) {
5
            System.out.println(Thread.currentThread().getName()+":"+i);
6
        }
7
    }
8
}
9
public class MyRunnableDemo {
10
    public static void main(String[] args) {
11
        // 创建MyRunnable类的对象
12
        MyRunnable my = new MyRunnable();
13

14
        // 创建Thread类的对象，把MyRunnable对象作为构造方法的参数
15
        // Thread(Runnable target)
16
        // Thread t1 = new Thread(my);
17
        // Thread t2 = new Thread(my);
18
        //Thread(Runnable target, String name)
19
        Thread t1 = new Thread(my,"坦克");
20
        Thread t2 = new Thread(my,"飞机");
21

22
        //启动线程
23
        t1.start();
24
        t2.start();
25
    }
26
}

1
public class MyCallable implements Callable<String> {
2
    @Override
3
    public String call() throws Exception {
4
        for (int i = 0; i < 100; i++) {
5
            System.out.println("跟女孩表白" + i);
6
        }
7
        // 返回值就表示线程运行完毕之后的结果
8
        return "答应";
9
    }
10
}
11
public class Demo {
12
    public static void main(String[] args) throws ExecutionException, InterruptedException {
13
        // 线程开启之后需要执行里面的call方法
14
        MyCallable mc = new MyCallable();
15

16
        // Thread t1 = new Thread(mc);
17

18
        // 可以获取线程执行完毕之后的结果.也可以作为参数传递给Thread对象
19
        FutureTask<String> ft = new FutureTask<>(mc);
20

21
        // 创建线程对象
22
        Thread t1 = new Thread(ft);
23

24
        String s = ft.get();
25
        // 开启线程
26
        t1.start();
27

28
        // String s = ft.get();
29
        System.out.println(s);
30
    }
31
}

1
public class MyThread extends Thread {
2
    public MyThread() {}
3
    public MyThread(String name) {
4
        super(name);
5
    }
6

7
    @Override
8
    public void run() {
9
        for (int i = 0; i < 100; i++) {
10
            System.out.println(getName()+":"+i);
11
        }
12
    }
13
}
14
public class MyThreadDemo {
15
    public static void main(String[] args) {
16
        MyThread my1 = new MyThread();
17
        MyThread my2 = new MyThread();
18

19
        // void setName(String name)：将此线程的名称更改为等于参数 name
20
        my1.setName("高铁");
21
        my2.setName("飞机");
22

23
        // Thread(String name)
24
        MyThread my1 = new MyThread("高铁");
25
        MyThread my2 = new MyThread("飞机");
26

27
        my1.start();
28
        my2.start();
29

30
        // static Thread currentThread() 返回对当前正在执行的线程对象的引用
31
        System.out.println(Thread.currentThread().getName());
32
    }
33
}