1
public class Demo04 extends Thread { // 继承Thread类
2
    @Override
3
    public void run() { // 重写run方法
4
        for (int i = 0; i < 5; i++) {
5
            System.out.println("线程里的方法：" + i);
6
        }
7
    }
8

9
    public static void main(String[] args) {
10
        Demo04 demo04 = new Demo04();
11
        demo04.start(); // 用start方法开启线程
12
        // demo04.run(); // 这个就不会另外起一个线程
13
        System.out.println("主线程中的方法");
14
    }
15
    // start方法会产生主方法和另一个线程的方法同时执行，而直接调用run方法就会按原来顺序从上往下执行
16
}

1
public class Demo05 implements Runnable { // 实现Runnable接口
2
    @Override
3
    public void run() {
4
        for (int i = 0; i < 5; i++) {
5
            System.out.println("线程里的方法" + i);
6
        }
7
    }
8

9
    public static void main(String[] args) {
10
        Demo05 demo05 = new Demo05(); // 创建线程对象
11
        new Thread(demo05).start(); // 通过线程对象来开启我们的线程
12
        // 重载方法：new Thread(实现Runnable接口的对象，线程的命名);
13
        System.out.println("主线程中的方法");
14
    }
15
}

1
public class Demo06 implements Runnable {
2
    private int TicketNum = 10; // 共同的抢票
3
    @Override
4
    public void run() {
5
        while (TicketNum > 0) {
6
            System.out.println(Thread.currentThread().getName() + "抢到了第" + (TicketNum--) + "张票");
7
            // Thread.currentThread().getName()可以获取线程的名称;
8
        }
9
    }
10

11
    public static void main(String[] args) {
12
        Demo06 Ticket = new Demo06();
13
        new Thread(Ticket, "1号线程").start();
14
        new Thread(Ticket, "2号线程").start();
15
        new Thread(Ticket, "3号线程").start();
16
    }
17
}
18
// 有可能会出现抢同一张票的情况
19
// 发现问题：多个线程操作同一个资源的情况下，线程不安全，数据紊乱

1
public interface Marry { // 定义接口
2
    void HappyMarry(); // 接口中的方法
3
}
4

5
class You implements Marry { // 真实的类实现接口
6
    @Override
7
    public void HappyMarry() {
8
        System.out.println("终于结婚了");
9
    }
10
}
11

12
class WeddingHouse implements Marry { // 代理类，实现接口
13
    private Marry target; // 定义一个接口的属性
14
    public WeddingHouse(Marry target) {
15
        this.target = target;
16
    }
17
    @Override
18
    public void HappyMarry() {
19
        before(); // 对原来接口的扩充
20
        target.HappyMarry(); // 原来接口的方法
21
        after(); // 对原来接口的扩充
22
    }
23
    private void after() {
24
        System.out.println("处理后事");
25
    }
26
    private void before() {
27
        System.out.println("邀请嘉宾");
28
    }
29
}
30

31
// 主函数中实现
32
public static void main(String[] args) {
33
    // 第一种，直接创建一个代理类的对象，并且在构造函数中传入实现接口的真实对象
34
    WeddingHouse weddingHouse = new WeddingHouse(new You());
35
    weddingHouse.HappyMarry();
36

37
    // 第二种，直接调用隐士对象，就相当是new Thread(实现Runnable接口的对象).start();
38
    new WeddingHouse(new You()).HappyMarry();
39

40
    // 第三种，直接采用匿名内部类，直接进行输出代理拓展的内容
41
    new WeddingHouse(new Marry() {
42
        @Override
43
        public void HappyMarry() {
44
            System.out.println("我也要结婚啦"); // 这里没有用真实的类，根据自己需求实现想要的功能
45
        }
46
    }).HappyMarry();
47
}

1
public interface Runnable {
2
    public abstract void run();
3
}

1
interface Love {
2
    void iLove();
3
}
4

5
class You implements Love { // 实现了接口
6
    @Override
7
    public void iLove() {
8
        System.out.println("i love you "); // 重写方法
9
    }
10
}
11

12
public static void main(String[] args) {
13
    Love love = new You(); // 新建一个接口的属性，创建一个实现类的对象
14
    love.iLove(); // 通过实例来调用方法
15

16
    Love love1 = new Love() {
17
        @Override
18
        public void iLove() {
19
            System.out.println("i love you 1");
20
        }
21
    }; // 匿名内部类，不用实现类就可以直接通过接口进行方法的内部实现
22
    love1.iLove();
23

24
    Love love2 = () -> System.out.println("i love you 2");
25
    // lambda表达式对上面的简化，实质是一样的。不需要写new，也不需要写方法名（因为只有一个）;只有实现方法体
26
    love2.iLove();
27
}
28
// 如果有参数：Love love2 = (参数) -> System.out.println("i love you 2");

1
class ThreadStop implements Runnable { // 线程类
2
    private boolean flag = true; // 提供线程体中的标识
3
    public void run() {
4
        while (flag) { // 线程使用标识
5
            System.out.println("Thread is running");
6
        }
7
    }
8
    public void stop() { // 提供外部方法停止
9
        flag = false;
10
    }
11
    public static void main(String[] args) {
12
        ThreadStop threadStop = new ThreadStop();
13
        new Thread(threadStop).start();
14
        for (int i = 0; i < 999; i++) {
15
            if (i == 900)
16
                threadStop.stop(); // 调用线程类提供的公有方法
17
            System.out.println("main is running");
18
        }
19
    }
20
}

1
setPriority(级别); // 设置线程优先级
2
getPriority();     // 获取线程的优先级

1
setDaemon(true)  // 设置守护线程，注意，一定要在start方法之前设置守护线程；
2
isDaemon()       // 判断是否是守护线程

1
public static void main(String[] args) {
2
    // 1.创建服务，创建线程池
3
    // newFixedThreadPool参数为：线程池大小
4
    ExecutorService service = Executors.newFixedThreadPool(10);
5
    // 执行
6
    service.execute(new 实现了Runnable接口的类);
7
    service.shutdown();
8
}