@TOC

Java 中传统多线程

线程初识

线程的概念

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

实现线程

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

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:设置/获取线程的幽灵状态

线程同步

多线程共享数据的问题

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

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

线程同步及实现机制

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

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(),...;}

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();
            }
        }
    }
}