java多线程简单demo

最新推荐文章于 2022-03-31 21:00:00 发布
最新推荐文章于 2022-03-31 21:00:00 发布
阅读量275 收藏 2
点赞数
分类专栏： java 文章标签： java 多线程

1、没有加上同步机制

import java.util.ArrayList;  
import java.util.List;  
import com.yingze.thread.ThreadDemo1.CarBigHouse.Car;  

public class ThreadDemo1 {  
    /** 
     * 姑且卖车的当做是生产者线程 
     */  
    public static class CarSeller implements Runnable {  

        private CarBigHouse bigHouse;  

        public CarSeller(CarBigHouse bigHouse) {  
            this.bigHouse = bigHouse;  
        }  

        public void run() {  
            for (int i = 0; i < 10; i++) {// 当做生产者线程，往仓库里边增加汽车，其实是触发增加汽车  
                int count = bigHouse.put();  
                System.out.println("生产汽车-->count = " + count);  
            }  
        }  
    }  

    /** 
     * 姑且买车的人当做是消费者线程 
     */  
    public static class Consumer implements Runnable {  

        private CarBigHouse bigHouse;  

        public Consumer(CarBigHouse bigHouse) {  
            this.bigHouse = bigHouse;  
        }  

        public void run() {  
            for (int i = 0; i < 10; i++) {// 当做消费者线程，从仓库里边提取汽车，其实是触发，从仓库里边提取一辆汽车出来  
                int count = bigHouse.get();  
                System.out.println("消费汽车-->count = " + count);  
            }  
        }  
    }  

    /** 
     * 这边姑且当做是车子big house放车子的仓库房 
     */  
    public static class CarBigHouse {  

        public int carNums = 0;// 这边是仓库房子中车子的数量总数  
        public List<Car> carList = new ArrayList<Car>();// 这边模拟用来放汽车的list  

        public int put() {// 提供给生产者放汽车到仓库的接口  
            Car car = CarFactory.makeNewCar();  
            carList.add(car);// 加到仓库中去  
            carNums++;// 总数增加1  
            return carNums;  
        }  

        public int get() {// 提供给消费者从这边取汽车接口  
            Car car = null;  
            if (carList.size() != 0) {// size不为空才去取车  
                car = carList.get(carList.size() - 1);// 提取最后一个car  
                carList.remove(car);// 从车库list中移除掉  
                carNums--;// 总数减少1  
            }  
            return carNums;  
        }  

        public static class Car {  

            public String carName;// 汽车名称  

            public double carPrice;// 汽车价格  

            public Car() {  
            }  

            public Car(String carName, double carPrice) {  
                this.carName = carName;  
                this.carPrice = carPrice;  
            }  
        }  
    }  

    /** 
     * 采用静态工厂方式创建car对象，这个只是简单模拟，不做设计模式上的过多考究 
     */  
    public static class CarFactory {  

        private CarFactory() {  
        }  

        public static Car makeNewCar(String carName, double carPrice) {  
            return new Car(carName, carPrice);  
        }  

        public static Car makeNewCar() {  
            return new Car();  
        }  
    }  

    /** 
     * 第一个版本的生产者和消费者线程，没有加上同步机制的演示例子 
     * 
     * @param args 
     */  
    public static void main(String[] args) {  
        CarBigHouse bigHouse = new CarBigHouse();  
        new Thread(new CarSeller(bigHouse)).start();  
        new Thread(new Consumer(bigHouse)).start();  
    }  
}

2、加上互斥锁

import java.util.ArrayList;  
import java.util.List;  
import java.util.concurrent.locks.ReentrantLock;  
import com.yingze.thread.ThreadDemo2.CarBigHouse.Car;  

public class ThreadDemo2 {  
    /** 
     * 姑且卖车的当做是生产者线程 
     */  
    public static class CarSeller implements Runnable {  

        private CarBigHouse bigHouse;  

        public CarSeller(CarBigHouse bigHouse) {  
            this.bigHouse = bigHouse;  
        }  

        public void run() {  
            for (int i = 0; i < 10; i++) {// 当做生产者线程，往仓库里边增加汽车，其实是触发增加汽车  
                int count = bigHouse.put();  
                System.out.println("生产汽车-->count = " + count);  
            }  
        }  
    }  

    /** 
     * 姑且买车的人当做是消费者线程 
     */  
    public static class Consumer implements Runnable {  

        private CarBigHouse bigHouse;  

        public Consumer(CarBigHouse bigHouse) {  
            this.bigHouse = bigHouse;  
        }  

        public void run() {  
            for (int i = 0; i < 10; i++) {// 当做消费者线程，从仓库里边提取汽车，其实是触发，从仓库里边提取一辆汽车出来  
                int count = bigHouse.get();  
                System.out.println("消费汽车-->count = " + count);  
            }  
        }  
    }  

    /** 
     * 这边姑且当做是车子big house放车子的仓库房 
     */  
    public static class CarBigHouse {  

        public int carNums = 0;// 这边是仓库房子中车子的数量总数  
        public List<Car> carList = new ArrayList<Car>();// 这边模拟用来放汽车的list  

        // 直接增加上synchronized关键字方式，成员方法，锁的是当前bigHouse对象  
        // 这种锁是互斥锁，方法在同一个时刻，只有一个线程可以访问到里边的代码          
        /*public synchronized int put() {// 提供给生产者放汽车到仓库的接口 
            Car car = CarFactory.makeNewCar(); 
            carList.add(car);// 加到仓库中去 
            carNums++;// 总数增加1 
            return carNums; 
        } 

        public synchronized int get() {// 提供给消费者从这边取汽车接口 
            Car car = null; 
            if (carList.size() != 0) {// size不为空才去取车 
                car = carList.get(carList.size() - 1);// 提取最后一个car 
                carList.remove(car);// 从从库list中移除掉 
                carNums--;// 总数减少1 
            } 
            return carNums; 
        }*/  

        //Lock提供了比synchronized方法和synchronized代码块更广泛的锁定操作，Lock更灵活的结构，有很大的差别，并且可以支持多个Condition对象 Lock是控制多个线程对共享资源进行访问的工具。通常，锁提供了对共享资源的独占访问，每次只能有一个线程对Lock对象加锁， 线程开始访问共享资源之前应先获得Lock对象。不过某些锁支持共享资源的并发访问，如：ReadWriteLock（读写锁），在线程安全控制中， 通常使用ReentrantLock（可重入锁）。使用该Lock对象可以显示加锁、释放锁。  
        final ReentrantLock lock=new ReentrantLock();  

        public int put() {// 提供给生产者放汽车到仓库的接口  
            //上锁  
            lock.lock();  
            try{  
                Car car = CarFactory.makeNewCar();  
                carList.add(car);// 加到仓库中去  
                carNums++;// 总数增加1                                
            }finally{  
                //释放锁  
                lock.unlock();  
            }  
            return carNums;  
        }  

        public int get() {// 提供给消费者从这边取汽车接口  
            //上锁  
            lock.lock();  
            try{  
                Car car = null;  
                if (carList.size() != 0) {// size不为空才去取车  
                    car = carList.get(carList.size() - 1);// 提取最后一个car  
                    carList.remove(car);// 从车库list中移除掉  
                    carNums--;// 总数减少1  
                }  
            }finally{  
                //释放锁  
                lock.unlock();  
            }  
            return carNums;  
        }  

        public static class Car {  

            public String carName;// 汽车名称  

            public double carPrice;// 汽车价格  

            public Car() {  
            }  

            public Car(String carName, double carPrice) {  
                this.carName = carName;  
                this.carPrice = carPrice;  
            }  
        }  
    }  

    /** 
     * 采用静态工厂方式创建car对象，这个只是简单模拟，不做设计模式上的过多考究 
     */  
    public static class CarFactory {  

        private CarFactory() {  
        }  

        public static Car makeNewCar(String carName, double carPrice) {  
            return new Car(carName, carPrice);  
        }  

        public static Car makeNewCar() {  
            return new Car();  
        }  
    }  

    /** 
     * 第一个版本的生产者和消费者线程，没有加上同步机制的演示例子 
     * 
     * @param args 
     */  
    public static void main(String[] args) {  
        CarBigHouse bigHouse = new CarBigHouse();  
        new Thread(new CarSeller(bigHouse)).start();  
        new Thread(new Consumer(bigHouse)).start();  
    }  
}

3、采用Object类的wait和notify方法或者notifyAll方法

import java.util.ArrayList;  
import java.util.List;  
import com.yingze.thread.ThreadDemo3.CarBigHouse.Car;  

/**   
 * @ClassName: ThreadDemo3 
 * @Description: TODO(采用Object类的wait和notify方法或者notifyAll方法（注意notify方法和notifyAll方法区别） notify是唤醒其中一个在等待的线程。  notifyAll是唤醒其他全部在等待的线程，但是至于哪个线程可以获得到锁还是要看竞争关系。线程状态：创建、运行、阻塞、销毁状态。（阻塞情况比较多，比如等待数据IO输入，阻塞了。）) 
 * 
 */  
public class ThreadDemo3 {  
    /** 
     * 姑且卖车的当做是生产者线程 
     */  
    public static class CarSeller implements Runnable {  

        private CarBigHouse bigHouse;  

        public CarSeller(CarBigHouse bigHouse) {  
            this.bigHouse = bigHouse;  
        }  

        public void run() {  
            for (int i = 0; i < 10; i++) {// 当做生产者线程，往仓库里边增加汽车，其实是触发增加汽车  
                int count = bigHouse.put();  
                System.out.println("生产汽车-->count = " + count);  
            }  
        }  

    }  

    /** 
     * 姑且买车的人当做是消费者线程 
     */  
    public static class Consumer implements Runnable {  
        private CarBigHouse bigHouse;  

        public Consumer(CarBigHouse bigHouse) {  
            this.bigHouse = bigHouse;  
        }  

        public void run() {  
            for (int i = 0; i < 10; i++) {// 当做消费者线程，从仓库里边提取汽车，其实是触发，从仓库里边提取一辆汽车出来  
                int count = bigHouse.get();  
                System.out.println("消费汽车-->count = " + count);  
            }  
        }  

    }  

    /** 
     * 这边姑且当做是车子big house放车子的仓库房 
     */  
    public static class CarBigHouse {  
        public int carNums = 0;// 这边是仓库房子中车子的数量总数  
        public List<Car> carList = new ArrayList<Car>();// 这边模拟用来放汽车的list  
        public static final int max = 3;// 简单设置下，做下上限设置  

        private Object lock = new Object();// 采用object的wait和notify方式处理同步问题  

        public int put() {// 提供给生产者放汽车到仓库的接口  
            synchronized (lock) {  
                if (carList.size() == max) {// 达到了上限，不再生产car  
                    try {  
                        lock.wait();// 进行阻塞处理  
                        System.out.println("生产达到上限...阻塞处理");  
                    } catch (InterruptedException e) {  
                        e.printStackTrace();  
                    }  
                }  
                Car car = CarFactory.makeNewCar();  
                carList.add(car);// 加到仓库中去  
                carNums++;// 总数增加1  
                lock.notify();// 唤醒等待的线程  
                return carNums;  
            }  
        }  

        public int get() {// 提供给消费者从这边取汽车接口  
            Car car = null;  
            synchronized (lock) {  
                if (carList.size() == 0) {// 没有汽车可以用来消费  
                    try {  
                        lock.wait();  
                        System.out.println("没有汽车...阻塞处理");  
                    } catch (InterruptedException e) {  
                        e.printStackTrace();  
                    }  
                }  
                if (carList.size() != 0) {// size不为空才去取车  
                    car = carList.get(carList.size() - 1);// 提取最后一个car  
                    carList.remove(car);// 从车库list中移除掉  
                    carNums--;// 总数减少1  
                }  
                lock.notify();  
                return carNums;  
            }  
        }  

        public static class Car {  

            public String carName;// 汽车名称  
            public double carPrice;// 汽车价格  

            public Car() {  
            }  

            public Car(String carName, double carPrice) {  
                this.carName = carName;  
                this.carPrice = carPrice;  
            }  
        }  
    }  

    /** 
     * 采用静态工厂方式创建car对象，这个只是简单模拟，不做设计模式上的过多考究 
     */  
    public static class CarFactory {  
        private CarFactory() {  
        }  

        public static Car makeNewCar(String carName, double carPrice) {  
            return new Car(carName, carPrice);  
        }  

        public static Car makeNewCar() {  
            return new Car();  
        }  
    }  

    /** 
     * 第二个版本的生产者和消费者线程，加上了同步机制的方法 
     * 
     * @param args 
     */  
    public static void main(String[] args) {  
        CarBigHouse bigHouse = new CarBigHouse();  
        new Thread(new CarSeller(bigHouse)).start();  
        new Thread(new Consumer(bigHouse)).start();  
    }  
}
xdhc304
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java多线程简单Demo
04-14
个人的小总结，适合初学者，包含了java多线程的基本概念，再配上简单的demo，相信初学者学习完对多线程能有较清晰的认识
Java之多线程(6个demo)
nuist_NJUPT的博客
08-06 3238
本文主要介绍Java中多线程，在Java中启动多线程的方法包括：继承Thread类或者实现Runnable接口，介绍了设置线程名称，设置线程优先级，设置守护线程等，介绍了线程同步，使用synchronized关键字和lock锁分别实现线程同步，解决线程安全问题，介绍了生产者和消费者模式，涉及线程延迟，等待，唤醒的方法。...
JavaWeb——多线程的五种创建方法（继承Thread类、匿名内部类、Runnable接口、匿名内部类重写runnable、lambda表达式），Thread类的常见构造方法、属性
char_m的博客
06-16 768
多线程创建继承Thread类查看线程 创建 一个进程包含一个主线程main，如果要新建线程就需要，使用线程中的start（）方法，此时内核中出现了一个pcb对象，这个pcb就会让cpu执行对应的代码， 继承Thread类 创建线程需要使用Thread 类，来创建一个Thread 的实例，另一方面还需要给这个线程指定，要执行哪些指令/代码，指定指令的方式有很多种方式，此处先用种简单的，直接继承 Thread 类，重写Thread类中的run方法. public class Create { stati
java多线程Demo
03-29
自己写的一些多线程的小Demo，在这里与大家分享一下。
实战体会Java多线程编程（一）
leagle
12-04 899
   在 Java 程序中使用多线程要比在 C 或 C++ 中容易得多，这是因为 Java 编程语言提供了语言级的支持。本文通过简单的编程示例来说明 Java 程序中的多线程是多么直观。读完本文以后，用户应该能够编写简单的多线程程序。 为什么会排队等待？下面的这个简单的 Java 程序完成四项不相关的任务。这样的程序有单个控制线程，控制在这四个任务之间线性地移动。此外，因为所需的资源 ?
java线程 demo_Java多线程demo
weixin_39924486的博客
02-21 180
近期考虑采用Java多线程实现给用户发短信的功能。自己做了一个简单的demo。demo需求如下：通过界面输入用户名、密码、手机号，点击添加，即可实时的为该用户发一条短信。实现过程如下：2、点击“添加”，通过ajax将参数传给后台。$.ajax({type:"post",url:"/test/addTestUserToQue",contentType:"application/json;char...
java多线程demo
11-11
本demo包含了所有多线程操作的demo以及详细注释本demo包含了所有多线程操作的demo以及详细注释
多线程demo
developer
03-31 593
public class ThreadDemo extends Thread { int i=0; public static void main(String[] args) { ThreadDemo mt1 = new ThreadDemo("Thread a"); ThreadDemo mt2 = new ThreadDemo("Thread b"); mt1.setName("线程1-----------..
Java多线程并发执行demo代码实例
08-18
主要介绍了Java多线程并发执行demo代码实例,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
java多线程代码demo
03-19
这些java的代码demo，是本人几篇多线程文章的实例代码 http://www.cnblogs.com/yaoxiaowen/p/6576779.html
轻量级java多线程池demo
01-08
线程可相互通信，可任意调度任务，类似Akka的Actor。如果内容对您有帮助，微信扫描下方的二维码支持下作者，谢谢！
多线程Demo
11-27
多线程演示Demo。几行代码让你了解多线程原理。
C#多线程Demo
01-30
里面有4个C#winfrom多线程的例子,需要可以下载下来看看,全方位让你看到,后台对于线程的操作,附带线程说明教程,最后还有线程池的使用说明和例子
多线程的简单代码demo
01-13
如果需要也可以私信我，这个是关于一些多线程的创建和使用的demo，也包含了线程池，还有callable的一些代码。 也可以观看我的博客自行复制黏贴，不需要的额花也可以直接下载哦！！！！！！！！！！！！！！！！！！...
java多线程demo_JAVA多线程demo
weixin_29489791的博客
02-18 658
基于上一篇文章介绍了一些关于JAVA多线程基础方面的理论知识，这一篇开始实际动手操作一番看看具体效果。1、通过集成java.lang.Thread线程类来创建一个线程package com.feizi.java.concurrency.thread;/*** Created by feizi on 2018/5/17.*/public class TestThread {public static...
Java多线程____一个简单的多线程demo
-
07-11 2584
1.实现runnable接口实现功能性解耦   package com.test.thread; public class TestRunnable implements Runnable{ @Override public void run() { for (int i = 0; i &lt; 20; i++) { System.out.println(Thread.cu...
java多线程简单Demo
bcbobo21cn的专栏
03-28 259
TestThr.java; class Mythread implements Runnable { private Thread t; private String threadName; Mythread( String name) { threadName = name; System.out.println("Creating " + threadName ); } public void run() { Sys
多线程 demo
jrunw的博客
03-27 457
1.  编译命令   gcc sem.c -lpthread 2.  执行命令 ./a.out 3.  代码： /* File sem.c */ #include #include #include #define MAXSTACK 100 int stack[MAXSTACK][2]; int stack2[MAXSTACK][2]; int size=0; in
java多线程并行demo
最新发布
11-25
以下是一个Java多线程并发执行的demo代码实例： ```java public class MultiThreadDemo { public static void main(String[] args) { MyThread mt1 = new MyThread("Thread 1"); MyThread mt2 = new MyThread(...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值