JAVA多线程基础

时间：2020-02-25 14:42:52 阅读：85 评论：0 收藏：0 [点我收藏+]

标签：te pro producer 自动调用 ons 方法一个 cer stack stat

1. 多进程与多线程

多进程：

每个独立执行的任务就是一个进程
操作系统将时间划分为多个时间片，在每个时间片内将CPU分配给某一个任务，时间片结束，CPU将自动回收，再分配给其他任务
多进程的缺点：比较笨重不好切换

多线程：

一个程序可包多个子任务，可串并行
一个子任务可以称为一个线程
在一个线程阻塞时，CPU可以调度另一个线程工作，这样CPU还是保留在本程序中。

2. java实现多线程的两种方法

1.线程继承Thread类，实现run方法。

public class Thread1 extends Thread{
    public void run()
    {
        System.out.println("hello");
    }
    public static void main(String[] a)
    {
        new Thread1().start();
    }
}

2.线程实现Runnable接口，实现run方法。(Runnable对象必须放在一个Thread类中才能运行)

public class Thread2 implements Runnable{
    public void run()
    {
        System.out.println("hello");
    }
    public static void main(String[] a)
    {
        new Thread(new Thread2()).start();
    }
}

start()方法会自动调用run方法
直接调用run()方法，会变成串行执行
main函数（线程）可能遭遇新线程结束，整个程序并不终止
整个程序终止时等所有的线程都终止

3. 多线程信息共享

应该注意两种实现方法信息共享的区别。

继承Tread类，只能通过设置Static静态常量实现变量共享，静态变量只有一个值。

public class ThreadDemo0
{
    public static void main(String [] args)
    {
        new TestThread0().start();
        new TestThread0().start();
        new TestThread0().start();
        new TestThread0().start();
    }
}
class TestThread0 extends Thread  
{
    //private int tickets=100;           //每个线程卖100张，没有共享
    private static int tickets=100;  //static变量是共享的，所有的线程共享
    public void run()
    {
        while(true)
        {
            if(tickets>0)
            {
                System.out.println(Thread.currentThread().getName() +
                " is selling ticket " + tickets);
                tickets = tickets - 1;
            }
            else
            {
                break;
            }
        }
    }
}

实现Runnable接口，设置一个private常量，TestThread1变量只被创建一次，而new Thread(t).start()只是把t包装为不同的对象，所以使用的是同一个对象，普通成员变量即可共享信息。


public class ThreadDemo1
{
    public static void main(String [] args)
    {
        TestThread1 t=new TestThread1();
        new Thread(t).start();
        new Thread(t).start();
        new Thread(t).start();
        new Thread(t).start();
    }
}
class TestThread1 implements Runnable
{
    private int tickets=100;
    public void run()
    {
        while(true)
        {
            if(tickets>0)
            {
                System.out.println(Thread.currentThread().getName() +" is selling ticket " + tickets);
                tickets--;
            }
            else
            {
                break;
            }
                
        }
    }
}

但是上述方法会存在工作副本的问题，应该采用volatile关键字使变量可以再各个进程之间通信，以及使用互斥锁synchronized对关键步骤进行加锁限制

//1.改写runnable接口方法
public class ThreadDemo3 {
    public static void main(String[] args) {
        TestThread3 t = new TestThread3();
        new Thread(t, "Thread-0").start();
        new Thread(t, "Thread-1").start();
        new Thread(t, "Thread-2").start();
        new Thread(t, "Thread-3").start();
    }
}

class TestThread3 implements Runnable {
    private volatile int tickets = 100; // 多个 线程在共享的

    public void run() {
        while (true) {
            sale();
            try {
                Thread.sleep(100);
            } catch (Exception e) {
                System.out.println(e.getMessage());
            }
            if (tickets <= 0) {
                break;
            }
        }

    }

    public synchronized void sale() { // 同步函数
        if (tickets > 0) {
            System.out.println(Thread.currentThread().getName() + " is saling ticket " + tickets--);
        }
    }
}

//2.改写继承Thread类的方法
public class ThreadDemo0
{
    public static void main(String [] args)
    {
        new TestThread0().start();
        new TestThread0().start();
        new TestThread0().start();
        new TestThread0().start();
    }
}
class TestThread0 extends Thread  
{
    volatile private static int tickets=100;  //static变量是共享的，所有的线程共享
    public void run() {
        while (true) {
            sale();
            try {
                Thread.sleep(100);
            } catch (Exception e) {
                System.out.println(e.getMessage());
            }
            if (tickets <= 0) {
                break;
            }
        }

    }

    public static synchronized void sale() { // 同步函数
        if (tickets > 0) {
            System.out.println(Thread.currentThread().getName() + " is saling ticket " + tickets--);
        }
    }
}

总结：

1.实现共享变量必须使这个变量的值只有一个。

2.某段时间只有一个进程对这个值操作。

3.应该让其他进程知晓这个变量的变化。

4. 多线程管理

4.1. 生产者消费者模型

package product;

/**
 *仓库
 */
class Storage {
    // 仓库容量为10
    private Product[] products = new Product[10];
    private int top = 0;

    // 生产者往仓库中放入产品
    public synchronized void push(Product product) {
        while (top == products.length) {
            try {
                System.out.println("producer wait");
                wait();//仓库已满，等待
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }
        //把产品放入仓库
        products[top++] = product;
        System.out.println(Thread.currentThread().getName() + " 生产了产品"
                + product);
        System.out.println("producer notifyAll");
        notifyAll();//唤醒等待线程
        

    }

    // 消费者从仓库中取出产品
    public synchronized Product pop() {
        while (top == 0) {
            try {
                System.out.println("consumer wait");
                System.out.println(top);
                wait();//仓库空，等待
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }

        }

        //从仓库中取产品
        --top;
        Product p = new Product(products[top].getId(), products[top].getName());
        products[top] = null;
        System.out.println(Thread.currentThread().getName() + " 消费了产品" + p);
        System.out.println("comsumer notifyAll");
        notifyAll();//唤醒等待线程
        return p;
    }
}

notify(),与notifyall()方法用来唤醒等待进程
wait()方法等待