多线程使用(一)

public class Test1 {
    public static void main(String[] args) throws InterruptedException {
        Thread t1=new Thread(new MyRunnable());
        t1.start();

        for (int i=0;i<5;i++){
            System.out.println("你快点开始啊："+i);
            Thread.sleep(500);
        }
        t1.interrupt();
    } 
} 
class MyRunnable implements Runnable{ 
    @Override
    public void run() {
        for(int i=0;i<10;i++){
            System.out.println("我要开始了哈："+i);
            try {
                Thread.sleep(500);
            } catch (InterruptedException e) {
//                System.out.println("你要干啥，我还不想消亡呢");
                return;
            }
        }
    }
}

8、线程状态

Enum Thread.State 枚举类型

9、守护线程和用户线程

线程分类：daemon线程，用户线程；

所有用户线程结束，程序才会结束；

守护线程，守护用户线程，当最后一个用户线程结束时，所有守护线程自动消亡；

设置：thread.setDaemon(true);

三、线程安全和不安全

示例代码，卖票：

public class Test2 {
    public static void main(String[] args) {
        Runnable tick=new Tick();
        new Thread(tick).start();
        new Thread(tick).start();
        new Thread(tick).start();
    }
}
class Tick implements Runnable{
    private int count=10;
    @Override
    public void run() {
        while (count>0){
            System.out.println("开始准备卖票");
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            count--;
            System.out.println("余票还剩："+count);
        }
    }
}

上述代码出现了逻辑错误，出票错误了。

线程不安全产生原因：多个线程同一个时间去争抢一个数据。

解决办法：排队执行，采用加锁的办法。

三种加锁机制：

同步代码块 synchronized
同步方法
显示锁Lock

1、同步代码块 synchronized

粒度较细，可以一行代码加锁；

synchronized(锁对象){

//排队执行的代码块

}

锁对象：java中任何对象都可以作为锁存在。

所有排队线程都需要使用相同的一个锁对象，不能每一个线程都有一个锁对象，这样就不能实现排队效果了。

class Tick implements Runnable{
    private int count=10;
    private Object obj=new Object();
    @Override
    public void run() {
        while (true){
            synchronized (obj){
                if(count<=0){
                    break;
                }
                System.out.println("开始准备卖票");
                try {
                    Thread.sleep(200);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                count--;
                System.out.println(Thread.currentThread().getName()+"卖票,余票还剩："+count);
            }
        }
    }
}

2、同步方法

以方法为单位加锁。

在方法，返回值类型前面加一个 synchronized

锁对象：非静态方法，是 this；静态方法，是类名.class

如果是不同的任务，就不会上锁，因为每个任务的this是不一样的。

同一个任务中有多个同步方法执行，那么其中一个方法执行，其他任何方法都执行不了。

因为所有同步方法的锁都是this，是同一个锁。

3、显示锁Lock

同步代码块和同步方法都属于隐式锁，Lock是隐式锁。

使用子类：ReentrantLock

new ReentrantLock();
lock()方法。
unlock()方法。

有参构造方法中，ReentrantLock(true) 表示公平锁，默认是false不公平锁。

4、显示锁和隐式锁的区别

5、公平锁和不公平锁

公平锁：排队的时候，谁先来谁先使用锁；

不公平锁：谁抢到谁使用；

同步代码块、同步方法、显示锁都是不公平锁。

6、线程死锁

A等待B，B等待A；

解决办法：在任何有可能导致锁产生的方法里，不要调用另外一个方法，让另一个锁产生；

即一个方法目前已经产生锁了，不要再去使用其他任何有可能导致锁的方法。

public static void main(String[] args) {
    Customer customer = new Customer();
    Shopkeeper shopkeeper = new Shopkeeper();
    new TestThread(customer, shopkeeper).start();
    customer.say(shopkeeper);
}
static class TestThread extends Thread {
    private Customer customer;
    private Shopkeeper shopkeeper;

    public TestThread(Customer customer, Shopkeeper shopkeeper) {
        this.customer = customer;
        this.shopkeeper = shopkeeper;
    }
    @Override
    public void run() {
        shopkeeper.say(customer);
    }
}
//顾客
static class Customer {
    public synchronized void say(Shopkeeper shopkeeper) {
        System.out.println("顾客：你先给我货，我给你钱");
        shopkeeper.respond();
    }
    public synchronized void respond() {
        System.out.println("顾客：我拿到了货，你拿到了钱");
    }
}
//店老板
static class Shopkeeper {
    public synchronized void say(Customer customer) {
        System.out.println("店老板：你先给我钱，我给你货");
        customer.respond();
    }
    public synchronized void respond() {
        System.out.println("店老板：我拿到了钱，你拿到了货");
    }
}

四、多线程通信

1、wait()等待、notify()唤醒

Object类中的wait和notify方法。

2、经典案例：生产者与消费者问题

生产者在生产时，消费者没有消费；消费者在消费时，生产者没有生产；

假设：一个厨师，一个服务员，一份食物；

案例中出现了三种情况：

当不存在同步方法设置，也不存在等待唤醒机制的时候，数据会出现错乱。因为生产者还没生产成功，消费者就来消费数据，数据是错误的。
当只有同步方法设置，没有等待唤醒机制的时候，会出现一直消费或者一直生产的情况。因为同步方法是不公平锁，会出现争抢，可能出现某一时间段一直消费或者一直生产情况。
设置了同步方法，也设置了等待唤醒机制的时候，生产者执行完成后，会唤醒this对象上等待的消费者，同时使自己处于等待状态；同样的，消费者消费完成后，会唤醒this对象上等待的生产者，同时使自己处于等待状态；这样保证了一次生产，一次消费有序进行。

/**
 * 生产者与消费者问题
 * @param args
 */
public static void main(String[] args) {
    Food food=new Food();
    new Thread(new Cook(food)).start();
    new Thread(new Waiter(food)).start();
} 
/**
 * 厨师线程,生产食物
 */
static class Cook implements Runnable{
    private Food food;

    public Cook(Food food){
        this.food=food;
    }

    @Override
    public void run() {
        //生成两种食物
        for (int i=0;i<10;i++){
            if(i%2==0){
                food.setNameAndTaste("青椒肉丝","酸甜味");
            }else{
                food.setNameAndTaste("毛血旺","麻辣味");
            }
        }
    }
}

/**
 * 服务员线程,消费食物
 */
static class Waiter implements Runnable{
    private Food food;

    public Waiter(Food food){
        this.food=food;
    }

    @Override
    public void run() {
        for (int i=0;i<10;i++){
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            food.get();
        }
    }
}

/**
 * 食物
 */
static class Food{
    //名称
    private String name;
    //口味
    private String taste;
    //flag true:生产  false:消费
    private boolean flag=true;

    /**
     * 设置食物名称和口味
     * @param name
     * @param taste
     */
    public synchronized void setNameAndTaste(String name,String taste){
        if(flag){
            this.name=name;
            try {
                Thread.sleep(200);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            this.taste=taste;
            //1、生产结束，改变标志量
            flag=false;
            //2、唤起消费进程
            this.notify();
            //3、生产进程等待
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    public synchronized void get(){
        if(!flag){
            System.out.println("服务生端走了食物："+name+"，口味："+taste);
            //1、更新标志量
            flag=true;
            //2、唤起生产线程
            this.notify();
            //3、消费线程等待
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

五、Runnable和Callable

Callable：主线程等待返回值，可以安排上千个线程去执行，主线程等待拿结果。

1、接口定义

public interface Callable<V>{

V call() throws Exception;

}

public interface Runnable{

public abstract void run();

}

2、Callable使用步骤

1、编写类实现Callable接口，实现方法：call()

Class XXX implements Callable<T>{

@Override

public <T> call() throws Exception{

return T;

}

2、创建FutureTask对象,并传入第一步编写的类对象callable：

FutureTask<Integer> future=new FutureTask<>(callable);

3、通过Thread启动线程。

new Thread(future).start();

3、Runnable和Callable的异同：

相同点：

都是接口
都可以编写多线程程序
都采用Thread.start()启动程序

不同点：

Runnable没有返回值；Callable可以返回执行结果
Runnable的run()不能抛出；Callable的call()允许抛出异常

4、Callable获取返回值

Callable支持获取返回结果，调用FutureTask.get()方法，此方法会阻塞主进程继续往下执行，如果不执行不会阻塞。

笑谈子云亭

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
打赏
0
评论
多线程使用(一)

目录一、基本概念1、进程：2、线程：3、线程调度3.1、分时调度3.2、抢占式调度3.3、数据库服务器响应4、同步与异步5、并发与并行二、线程使用1、Thread构造方法与定义2、内存结构3、使用线程三种方式：4、继承Thread5、实现接口Runnable6、实现Runnable与继承Thread7、线程休眠 \ 阻塞 \ 中断1、线程休眠2、线程阻塞：3、线程中断8、线程状态9、守护线程和用户线程三、线...
复制链接

扫一扫