@TOC

Java 中传统多线程

线程初识

线程的概念

当代操作系统中,可以独立并发执行的基本单元 轻量:占用系统资源极少 独立:操作系统可以独立调度和分派的基本单元 共享:共享进程中的资源

实现线程

继承Thread类,重写run方法 实现Runnable接口,实现run方法

copy
package com.xc.test.threadtest;

public class ThreadDemo {
    public static void main(String[] args) throws InterruptedException {
        Thread threadA = new ThreadA();
        threadA.setName("ThreadA");
        threadA.start();

        ThreadB threadB = new ThreadB();
        Thread thread = new Thread(threadB);
        thread.start();

        while (true) {
            Thread.sleep(1000);
            System.out.println(3);
        }

    }
}

class ThreadA extends Thread {
    public void run() {
        while (true) {
            System.out.println(this.getName() + ":" + 2);
        }
    }
}

class ThreadB implements Runnable {
    public void run() {
        while (true) {
            System.out.println(4);
        }

    }
}

线程的生命周期

新建:线程刚刚创建完毕 可运行:启动线程后 运行:操作系统调度 阻塞/等待:等待某种资源或时间片到 消亡:退出run方法

常用API

类方法:针对当前运行线程 currentThread:获取当前运行线程的引用 yield:使得当前运行线程放弃当前时间片 sleep:使得当前运行线程休眠多少时间(单位是毫秒)

实例方法:针对指定线程 start:启动线程 setP:设置/获取线程优先级 setName/getName:设置/获取线程名称 setD:设置/获取线程的幽灵状态

线程同步

多线程共享数据的问题

多个线程并发访问同一个数据时,容易发生数据状态不稳定 使用锁机制完成线程同步(同-协同,步-调用顺序)

copy
package com.xc.test.threadtest;

public class SysDemo {
    public static void main(String[] args) {
        Data data = new Data();
        new ThreadC(data).start();
        new ThreadC(data).start();
    }
}

class Data {
    int i;

    public void process() {
        System.out.println("Before:" + i);
        try {
            Thread.sleep(100);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        i++;
        System.out.println("After:" + i);
    }
}

class ThreadC extends Thread {
    Data data;

    public ThreadC(Data data) {
        this.data = data;
    }

    public void run() {
        super.run();
        while (true) {
            data.process();
        }
    }
}


Before:0
Before:0
After:1
After:2
Before:2
Before:2
After:3
Before:4
After:4

线程同步及实现机制

每个类一把锁,每个对象一把锁 只有获取锁的线程可以进入同步区域

copy
class Data {
    int i;

    public void process() {
        synchronized (this) {//对象锁(任意对象),同步块
            System.out.println("Before:" + i);
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
            }
            i++;
            System.out.println("After:" + i);
        }
    }
}


class Data {
    int i;

    public synchronized void process() {//对象锁(当前对象),同步方法
        System.out.println("Before:" + i);
        try {
            Thread.sleep(100);
        } catch (InterruptedException e) {
        }
        i++;
        System.out.println("After:" + i);
    }
}


Before:0
After:1
Before:1
After:2
Before:2
After:3
Before:3
After:4

线程间通讯

线程间通讯模型

wait:使当前线程进入指定对象的等待池 notify:从指定对象等待池中唤醒一个等待线程 notifyAll:从指定对象等待池中唤醒全部等待线程 只有获得该对象的锁后才可以调用上述方法

线程中通讯的实现

生产者:synchronized(obj){...;obj.notifyAll()} 消费者:synchronized(obj){obj.wait(),...;}

copy
package com.xc.test.threadtest;

public class WnDemo {
    public static void main(String[] args) {
        Data2 data2 = new Data2();
        new Producer(data2).start();
        new Consumer(data2).start();
    }
}

class Data2 {
    int i;

    public void add() {
        synchronized (this) {
            i++;
            if (i % 5 == 0) {
                notifyAll();
            }
        }
    }

    public void sub() {
        synchronized (this) {
            try {
                this.wait();
            } catch (InterruptedException e) {
            }
        }
        System.out.println("Before:" + i);
        i++;
        System.out.println("After:" + i);
    }
}

class Consumer extends Thread {
    Data2 data;

    public Consumer(Data2 data) {
        this.data = data;
    }

    public void run() {
        while (true) {
            while (true) {
                data.sub();
            }
        }
    }
}

class Producer extends Thread {
    Data2 data;

    public Producer(Data2 data) {
        this.data = data;
    }

    public void run() {
        while (true) {
            while (true) {
                data.add();
            }
        }
    }
}