多线程的使用

 一.继承Thread类创建线程

package com.thread1;
/**
 * 1.继承Thread类创建线程
 */
public class ThreadTest extends Thread{
    private int count=0;
    /**
     * 线程执行任务的方法
     */
    @Override
    public void run() {
        while(count<100){
            count++;
            System.out.println("count的值是："+count);
        }
    }
    /**
     * 主线程的入口
     */
    public static void main(String[] args) {
        //创建线程对象
        ThreadTest tt=new ThreadTest();
        
        //启动线程(其实调用线程对象里的run方法)
        tt.start();
    }

}

二..实现Runnable接口创建线程

package com.rannable;
/**
 * 2.实现Runnable接口创建线程
 * @author Administrator
 *
 */
public class RunnableTest implements Runnable{
    private int count=0;
    /**
     * 执行线程任务
     */
    @Override
    public void run() {
        while(count<100){
            count++;
        }
        System.out.println("count的值："+count);
        
    }
    
    /**
     *主线程
     */
    public static void main(String[] args) {
        //通过创建线程对象
        RunnableTest rt=new RunnableTest();
        
        Thread t=new Thread(rt);
        //启动线程
        t.start();
        Thread t2=new Thread(rt);
        //启动线程
        t2.start();
        Thread t3=new Thread(rt);
        //启动线程
        t3.start();
        Thread t4=new Thread(rt);
        //启动线程
        t4.start();

    }


}

三.join线程插队

package com.join;
/**
 * 3.使用join时对给变量赋值的影响
 *
 */
public class JoinSetFieldTest extends Thread{
    public String val1;
    public String val2;
    /**线程执行任务的方法*/
    public void run(){
        val1="456";
        val2="123";
    }
    

    /**主线程入口
     * @throws InterruptedException */
    public static void main(String[] args) throws InterruptedException {
        //线程对象实例化
        JoinSetFieldTest jsft =new JoinSetFieldTest();
        
        //启动线程
        jsft.start();
        
        //表示先让上面的线程执行完毕，再次执行当前线程：大脑没停，动作停了
        //jsft.join();
        System.out.println("val1:"+jsft.val1);
        System.out.println("val2:"+jsft.val2);

    }

}

package com.join;

/**
 * 3.使用join方法暂停执行当前线程，等待调用该方法的线程结束之后再继续执行本线程
 */
public class JoinTest extends Thread {
    // 获取线程的名字
    public JoinTest(String name) {
        super(name);
    }
    /**
     * 线程任务执行的方法
     */
    public void run() {
        for (int i = 1; i <= 5; i++) {
            // 输出当前线程的名字
            System.out.println(Thread.currentThread().getName() + "" + i);
        }
    }

    /**
     * 主线程入口
     * 
     * @param args
     * @throws InterruptedException
     */
    public static void main(String[] args) throws InterruptedException {

        for (int i = 1; i <= 10; i++) {
            if (i == 5) {
                JoinTest jt = new JoinTest("JoinTest");
                jt.start();
                //把该线程通过join方法，插入到下面主线程的前面，也就是执行该线程
                //暂停将主线程阻塞状态，等待该线程执行完，再执行主线程
                jt.join();
            }
            System.out.println(Thread.currentThread().getName() + "" + i);
        }
    }

}

四.sleep线程休眠

package com.sleep;
/**
 * 5.线程休眠
 * @author Administrator
 *
 */
public class SleepTest extends Thread{
    
    public static void se() throws InterruptedException{
        /**
         * 线程每次睡眠1秒
         */
        for (int i = 1; i <= 5; i++) {
            System.out.println(i+"秒");
            //线程睡眠1秒
            Thread.sleep(1000);//睡眠状态：大脑和动作处于不可运转状态，阻塞状态
        }
    }

    /** 主线程入口
     * @throws InterruptedException */
    public static void main(String[] args) throws InterruptedException {
             System.out.println("等待");
             
             //让主线程等待5秒后再次执行
             SleepTest.se();
             
             System.out.println("start");
    }

}

五.同步代码块/代码块

1.创建银行账户表

package cn.com.jbit;

//银行帐户类
public class Account {
 private int balance = 500; //余额
 public int getBalance() {
    return balance;
 }
 //取款
 public void withdraw(int amount) {
    balance = balance - amount;
 }
}

2.取款线程类

package cn.com.jbit;

//取款的线程类
public class TestAccount implements Runnable {
    // 所有用TestAccount对象创建的线程共享同一个帐户对象
    private Account acct = new Account();

    public void run() {
        for (int i = 0; i < 5; i++) {
            makeWithdrawal(100);// 取款
            if (acct.getBalance() < 0) {
                System.out.println("账户透支了!");
            }
        }
    }

    private void makeWithdrawal(int amt) {
        synchronized (acct) {
            if (acct.getBalance() >= amt) {
                System.out.println(Thread.currentThread().getName() + " 准备取款");
                try {
                    Thread.sleep(500);// 0.5秒后实现取款
                } catch (InterruptedException ex) {
                }
                // 如果余额足够，则取款
                acct.withdraw(amt);
                System.out.println(Thread.currentThread().getName() + " 完成取款");
            } else {
                // 余额不足给出提示
                System.out.println("余额不足以支付 "
                        + Thread.currentThread().getName() + " 的取款，余额为 "
                        + acct.getBalance());
            }
        }
    }
}

3.测试类

package cn.com.jbit;
//测试类
public class TestWithdrawal {
 public static void main (String [] args) {
     //创建两个线程
       TestAccount r = new TestAccount();
     Thread one = new Thread(r);
     Thread two = new Thread(r);
     one.setName("张三");
     two.setName("张三的妻子");
     //启动线程
     one.start();
     two.start();
 }
}

六、线程间通信

案例1：

package cn.com.jbit;
//测试线程间通信
public class CommunicateThread implements Runnable{
    public static void main(String[] args) {
        CommunicateThread thread=new CommunicateThread();
        Thread ta=new Thread(thread,"线程ta");
        Thread tb=new Thread(thread,"线程tb");
        ta.start();
        tb.start();
    }
  //同步run()方法
    synchronized public void run() {
        for(int i=0;i<5;i++){
            System.out.println(Thread.currentThread().getName()+i);
            if(i==2){
                try {                
                    wait();//退出运行态，放弃资源锁，进入到等待队列
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            if(i==1){                               
                notify(); //从等待序列中唤起一个线程
            }
            if(i==4){
                notify();
            }
        }
    }
}

案例2：

1.采购类

package com.thread.customer;

public class Purchase {
    private int count;

    public synchronized void completes(int count){
        if(count==0){
            System.out.println("库存不够，请等待采购入库....");
            try {
                wait();
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }
        count=count;
        notify();        //通知顾客可以购买了
    }
    public synchronized void getGoods(int count){
        if(count==0){
            System.out.println("采购还未入库，顾客停止购买");
            try {
                wait();
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }
        count=count;
        notify();
        System.out.println("采购入库完成，请继续购买。。。。。。");

    } 
}

2.采购线程类

package com.thread.customer;

public class PurchaseThead extends Thread{
    private Purchase p;
    public PurchaseThead(Purchase p){
        this.p=p;
    }
    public void run(){
        int count=0;
        do{
            try {
                Thread.sleep((int)(Math.random()*3000));
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
            p.getGoods(count);
            count++;
        }while(count<10);
    }
}

3.顾客类

package com.thread.customer;

public class CustomerThread extends Thread {
    private Purchase p;
    public CustomerThread(Purchase p){
        this.p=p;
    }
    public void run(){
        int count=10;
        do{
            try {
                Thread.sleep((int)(Math.random()*3000));
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
            count--;
            p.getGoods(count);
            
        }while(count>0);
    }
}

4.测试类

package com.thread.customer;

public class Test {

    public static void main(String[] args) {
        Purchase p=new Purchase();
        new CustomerThread(p).start();
        new PurchaseThead(p).start();

    }

}