java多线程（包含生产者与消费者例子）

最新推荐文章于 2022-07-21 20:11:42 发布

icarusliu81

最新推荐文章于 2022-07-21 20:11:42 发布

阅读量282

点赞数

分类专栏： java 文章标签：多线程 Java thread JVM J#

java 专栏收录该内容

18 篇文章 0 订阅

订阅专栏

java多线程
1.任务的run()方法通常总会有某种形式的循环，使得任务一直运行下去直到不再需要，所以要设定跳出循环的条件。通常，它被写成无限循环的形式这就意味着，除非有个条件使用它终止，否则它将永远运行下去。
2.使用Executor:
    java.util.consurrent包中的执行器将为你管理Thread对象，从而简化了并发编程。如：
        ExecutorService exec = Executors.newCachedThreadPool();
        //..= Executors.newFIxedThreadPool(5)是有数量限制的线程集
        //..=Executors.newSingleThreadExecutor()是顺序执行的线程集
        exec.execute(...);
        exec.shutdown();
3.几种方法：
    1.sleep():休眠一段时间
    2.yield():报告自己重要的工作已经完成，可以休息一段时间，让CPU执行其它线程。但是这里不保证会不执行这个线程而去执行其它线程，它只是将本线程的优先级降低来建议运行其它线程。
    3.wait():
    4.join():如在B的run()当中运行A.join():表明B要在A执行完毕或者被中断之后才能继续进行。

4.volatile关键字：
Volatile修饰的成员变量在每次被线程访问时，都强迫从共享内存中重读该成员变量的值。而且，当成员变量发生变化时，强迫线程将变化值回写到共享内存。这样在任何时刻，两个不同的线程总是看到某个成员变量的同一个值。
Java语言规范中指出：为了获得最佳速度，允许线程保存共享成员变量的私有拷贝，而且只当线程进入或者离开同步代码块时才与共享成员变量的原始值对比。
这样当多个线程同时与某个对象交互时，就必须要注意到要让线程及时的得到共享成员变量的变化。
而volatile关键字就是提示VM：对于这个成员变量不能保存它的私有拷贝，而应直接与共享成员变量交互。
使用建议：在两个或者更多的线程访问的成员变量上使用volatile。当要访问的变量已在synchronized代码块中，或者为常量时，不必使用。
由于使用volatile屏蔽掉了VM中必要的代码优化，所以在效率上比较低，因此一定在必要时才使用此关键字。

5.守护线程：
   守护线程在没有用户线程可服务时自动离开，在Java中比较特殊的线程是被称为守护（Daemon）线程的低级别线程。这个线程具有最低的优先级，用于为系统中的其它对象和线程提供服务。将一个用户线程设置为守护线程的方式是在线程对象创建之前调用线程对象的setDaemon方法。典型的守护线程例子是JVM中的系统资源自动回收线程，我们所熟悉的Java垃圾回收线程就是一个典型的守护线程，当我们的程序中不再有任何运行中的Thread，程序就不会再产生垃圾，垃圾回收器也就无事可做，所以当垃圾回收线程是Java虚拟机上仅剩的线程时，Java虚拟机会自动离开。它始终在低级别的状态中运行，用于实时监控和管理系统中的可回收资源。守护进程（Daemon）是运行在后台的一种特殊进程。它独立于控制终端并且周期性地执行某种任务或等待处理某些发生的事件。也就是说守护线程不依赖于终端，但是依赖于系统，与系统“同生共死”。那Java的守护线程是什么样子的呢。当 JVM中所有的线程都是守护线程的时候，JVM就可以退出了；如果还有一个或以上的非守护线程则JVM不会退出。

6.捕获异常
    由于线程的本质我，使得不能捕获从线程中逃逸的异常。一旦异常逃出任务的run()方法，它就公向外传播到控制台，除非你采取特殊的步骤捕获这种错误的异常。以前可以用线程组来完成这一工作，但是现在可以用Executor来解决这个问题，因此不再需要了解有关线程组的任何知识了。

join()方法的使用：

public class A{
    public void run(){
       try{
         sleep(1500);
       }catch(InterruptedException ex){}
   }
}

public class B{
    private A a;
    public B(A a){this.a = a;}
   pubic void run(){
       try{
           a.join();
       }catch(InterruptedException ex){}
    }
}

public static void main(String[] args){
    A a = new A();
    B b = new B(a);
    a.start();
    b.start();
   
    a.interrupt();//b在start之后就一直等待，直到执行到a.interrupt()或者a已经执行完毕（
a休眠时间到
}

生产者与消费者

package com.icarusliu.learn.others;

/**
 * 账户
 * @author liuqi
 *
 */
public class Account {
    private int account;
    
    public Account(){
        this.account = 0;
    }
    
    public int getAccount(){
        return this.account;
    }
    
    public synchronized void deposite(int count){
        this.account += count;
        System.out.println("Deposite " + count);
        notifyAll();//每存一次就唤醒挂起在这个对象上面的线程
    }
    
    public synchronized void withdraw(int count){
        try{
            while(account<count){//如果不够，则进入等待，当有存储进行时，就会唤醒然后继续判断 是否足够
                System.out.println("It's too less!");
                wait();
            }
        }catch(Exception ex){
            ex.printStackTrace();
        }
        
        account -= count;
        System.out.println("Withdraw " + count);
    }
}

package com.icarusliu.learn.others;

/**
 * 消费者
 * @author liuqi
 *
 */
public class Consumer extends Thread{
    Account account;

    public Consumer(Account account    ){
        this.account = account;
    }
    
    public void run(){
        account.withdraw(100);
    }
}

package com.icarusliu.learn.others;

/**
 * 生产者
 * @author liuqi
 *
 */
public class Producer extends Thread{
    Account account;

    public Producer(Account account    ){
        this.account = account;
    }
    
    public void run(){
        int count = 0;
        while(count++<12){
            account.deposite(10);
            try{
                sleep(10);
            }catch(Exception ex){
                ex.printStackTrace();
            }
        }
    }
}

package com.icarusliu.learn.others;

public class ThreadTest {
    Account count = new Account();
    Consumer cThread = new Consumer(count);
    Producer pThread = new Producer(count);
    
    public static void main(String args[]){
        ThreadTest t = new ThreadTest();
        t.cThread.start();
        t.pThread.start();
    }
}

//例子2，两个线程，一个给j加1，一个减1
package com.icarusliu.learn.thread;

public class ThreadTest {
    private int j;
    
    public ThreadTest(int j){
        this.j= j;
    }
    
    public synchronized void inc(){
        j++;
        j++;
        System.out.println("Add");
    }
    
    public synchronized void dec(){
        j--;
        System.out.println("Delete");
    }
    
    public class Inc extends Thread{
        public void run(){
            inc();
        }
    }
    
    public class Dec extends Thread{
        public void run(){
            dec();
        }
    }
    
    public static void main(String args[]){
        ThreadTest t = new ThreadTest(0);
        int i = 0;
        ThreadGroup g = new ThreadGroup("g");
        for(i=0;i<100;i++){
            Thread incThread = new Thread(g,t.new Inc(),"inc");
            Thread decThread = new Thread(g,t.new Dec(),"dec");
            incThread.start();
            decThread.start();
        }
        while(g.activeCount()!=0);
        System.out.println(t.j);
    }
}

总结：
1.线程中同步代码一般是放在要共享的数据结构当中，而与特定的线程无关。
2.可以利用线程组来判断是否所运行的线程都已经运行完成。