java多线程例子_java 多线程简单例子

实现线程的方式是一，继承Thread类，重写父类的run()方法

二，实现接口Runnable中的run()方法。

下面是简单的例子

例子1：银行存取钱问题

package com.direct.demo;

public class Bank {

private static int money;

public int getMoney(){

return money;

}

public void saveMoney(int m){

synchronized (this) {

System.out.println("存钱后的总金额："+(money+=m));

}

}

public void drawMoney(int m){

synchronized (this) {

Bank bank = new Bank();

if (bank.getMoney()<=0) {

System.out.println("没得钱，取个pi");

}else {

System.out.println("取钱后剩的总金额："+(money-=m));

}

}

}

public static void main(String[] args) {

Man m1 = new Man();

Women w = new Women();

Thread t1 = new Thread(m1);

Thread t2 = new Thread(m1);

Thread t3 = new Thread(m1);

Thread t4 = new Thread(w);

Thread t5 = new Thread(w);

Thread t6 = new Thread(w);

t1.start();

t2.start();

t3.start();

t4.start();

t5.start();

t6.start();

}

}

class Man implements Runnable{

private Bank bank = new Bank();

public void run() {

int m = 100;

int i=0;

while (i<5) {

bank.saveMoney(m);

i++;

try {

Thread.sleep(100);

} catch (InterruptedException e) {

e.printStackTrace();

}

}

}

}

class Women implements Runnable{

private Bank bank = new Bank();

public void run() {

int m = 100;

int i=0;

//bank.getMoney()>0

while (i<5) {

bank.drawMoney(m);

try {

Thread.sleep(100);

} catch (InterruptedException e) {

e.printStackTrace();

}

i++;

}

}

}

例子2：生产者与消费者问题

package com.direct.demo;

public class Clerk {

private int product = -1;

//这个方法由生产者调用

public synchronized void setProduct(int product){

if (this.product != -1) {

try {

wait();

} catch (InterruptedException e) {

e.printStackTrace();

}

}

this.product = product;

System.out.printf("生产者设定 (%d)%n",this.product);

notify();

}

//这个方法由消费者调用

public synchronized int getProduct(){

if (this.product==-1) {

try {

wait();

} catch (InterruptedException e) {

e.printStackTrace();

}

}

int p = this.product;

System.out.printf("消费者取走 (%d)%n",this.product);

this.product = -1;

notify();

return p;

}

public static void main(String[] args) {

Clerk clerk = new Clerk();

new Thread(new ProducerInt(clerk)).start();

new Thread(new ConsumerInt(clerk)).start();

}

}

class ProducerInt implements Runnable{

private Clerk clerk;

public ProducerInt(Clerk clerk){

this.clerk = clerk;

}

public void run() {

System.out.println("生产者开始生产整数了..................");

for (int product = 1; product <= 10; product++) {

try {

Thread.sleep((int)Math.random()*300);

} catch (InterruptedException e) {

e.printStackTrace();

}

clerk.setProduct(product);

}

}

}

class ConsumerInt implements Runnable{

private Clerk clerk;

public ConsumerInt(Clerk clerk){

this.clerk = clerk;

}

public void run() {

System.out.println("消费者开始消耗整数........");

for (int i = 1; i <=10 ; i++) {

try {

Thread.sleep((int)Math.random()*300);

} catch (InterruptedException e) {

e.printStackTrace();

}

clerk.getProduct();//从店员取走整数

}

}

}

例子3：购票窗口实现票数同步

package com.direct.demo;

import java.util.concurrent.locks.Lock;

import java.util.concurrent.locks.ReentrantLock;

public class ThreadTicket {

public static void main(String[] args) {

Booking b1 = new Booking("军人售票口");

Booking b2 = new Booking("学生售票口");

Booking b3 = new Booking("老年人售票口");

Booking b4 = new Booking("网上售票口");

b1.start();

b2.start();

b3.start();

b4.start();

}

}

/*

* 多窗口卖票系统。多线程

* 票数为静态的，共享数据

* synchronized(对象){}代码块中的内容是加锁的，

* 即当一个线程在使用时，其他线程不可以进入。

* 使得共享资源数据的安全。

*/

class Booking extends Thread{

public Booking(String name){

super(name);

}

static int ticket = 50;//票数共50张

Lock lock = new ReentrantLock();//明锁

/*

* ReentrantLock根据传入构造方法的布尔型参数实例化出Sync的实现类FairSync和NonfairSync

* ，分别表示公平的Sync和非公平的Sync。

* 由于ReentrantLock我们用的比较多的是非公平锁

ReentrantLock 和synchronized 均为重入锁

* 1. ReenTrantLock可以指定是公平锁还是非公平锁。而synchronized只能是非公平锁。所谓的公平锁就是先等待的线程先获得锁。

2. ReenTrantLock提供了一个Condition(条件)类，用来实现分组唤醒需要唤醒的线程们，而不是像synchronized要么随机唤醒一个线程要么唤醒全部线程。

3. ReenTrantLock提供了一种能够中断等待锁的线程的机制，通过lock.lockInterruptibly()来实现这个机制。

对ReentrantLock的可重入锁这篇博客使用简单的例子进行讲解，  http://blog.csdn.net/yanyan19880509/article/details/52345422

* Lock是个接口，只能实例化它的子类

* 明锁适合高并发，上万

* 暗锁适合并发率不高时，效率高

*/

//重写run方法，

public void run(){

while(ticket>0){

synchronized (Booking.class) {

if (ticket>0) {

System.out.println(super.getName()+"窗口---->卖出的车票号No."+ticket);

ticket--;

}else {

System.out.println(super.getName()+"票已售罄！！!");

}

try {

sleep(100);//睡100毫秒，抛出多线程异常

} catch (InterruptedException e) {

e.printStackTrace();

}

}

/*lock.lock();//加锁，锁定以下代码

if (ticket>0) {

System.out.println(super.getName()+"卖票："+ticket);

ticket--;

}else {

System.out.println(super.getName()+"票已售罄！！！");

}

try {

Thread.sleep(100);

} catch (InterruptedException e) {

e.printStackTrace();

}

lock.unlock();//解锁

*/}

}

}

例子4：线程中sleep()和wait()方法测试

package com.direct.demo;

public class TestSleepaWait {

public static void main(String[] args) {

new Thread(new Thread1()).start();

try {

Thread.sleep(5000);

} catch (InterruptedException e) {

e.printStackTrace();

}

new Thread(new Thread2()).start();

}

}

class Thread1 implements Runnable{

public void run() {

synchronized (TestSleepaWait.class) {

System.out.println("Thread1 is start........");

System.out.println("Thread1 is wait..............");

try {

//调用wait方法，线程会放弃对象锁，进入等待对象的等待锁定池

TestSleepaWait.class.wait();

} catch (InterruptedException e) {

e.printStackTrace();

}

System.out.println("Thread1 is go on........");

System.out.println("Thread1 is over!");

}

}

}

class Thread2 implements Runnable{

@Override

public void run() {

synchronized (TestSleepaWait.class) {

System.out.println("Thread2 is enter..........");

System.out.println("Thread2 is sleep.......");

//只有针对对象调用notify()方法后本线程才进入对象锁定池

//准备获取对象进入运行状态

TestSleepaWait.class.notify();

//===============

//如果把上句注释掉。即对象锁调用了wait方法，但是没有调用notify

//程序就一致处于挂起状态

try {

Thread.sleep(5000);

//sleep方法暂停执行时间，让出CPU，监控状态保持，

//时间到 了就回复运行， 不会释放对象锁

} catch (InterruptedException e) {

e.printStackTrace();

}

System.out.println("Thread2 is going on..........");

System.out.println("Thread2 is over!!!!");

}

}

}

例子5：sleep()实现对象存取值

package com.direct.demo;

public class ThreadCom {

public static void main(String[] args) {

Person person = new Person();

new Thread(new Producer(person)).start();

new Thread(new Consumer(person)).start();

}

}

class Person{

private String name = "张杰";

private String sex = "男";

public synchronized void put(String name,String sex){

this.name = name;

this.sex = sex;

try {

Thread.sleep(100);

} catch (InterruptedException e) {

e.printStackTrace();

}

}

//方法加锁

public synchronized void get(){

System.out.println(name+"----->"+sex);

try {

Thread.sleep(100);

} catch (InterruptedException e) {

e.printStackTrace();

}

}

}

class Consumer implements Runnable{

Person person;

public Consumer(Person person){

this.person = person;

}

public void run() {

while(true){

person.get();

}

}

}

class Producer implements Runnable{

Person person;

public Producer(Person person){

this.person = person;

}

public void run() {

int i = 0;

while (true) {

if (i==0) {

person.put("谢娜", "女");

}else {

person.put("张杰", "男");

}

i = (i+1)%2;//奇数和偶数

}

}

}

例子6：死锁发生条件

在写代码时要避免死锁

package com.direct.demo;

public class DeadLock {

public static void main(String[] args) {

ThreadLock tl = new ThreadLock(true);

ThreadLock tl2 = new ThreadLock(false);

new Thread(tl).start();

new Thread(tl2).start();

}

}

/*

* 死锁的产生条件：

* 1、至少一个资源共享

* 2、至少有一个线程(任务)，必须持有资源，且等待获取别的线程持有的资源

* 3、任务抢不到资源

* 4、必须有无限循环

* (1) 互斥条件：一个资源每次只能被一个进程使用。

* (2) 请求与保持条件：一个进程因请求资源而阻塞时，对已获得的资源保持不放。

* (3) 不剥夺条件:进程已获得的资源，在末使用完之前，不能强行剥夺。

* (4) 循环等待条件:若干进程之间形成一种头尾相接的循环等待资源关系。

* 举例说明：不可剥夺资源A、B，进程C、D

* 不可剥夺资源：一个进程申请了之后，不能强制收回，只能进程结束之后自动释放。内存是可剥夺资源

* 进程C申请了资源A，进程D申请了资源B。

* 接下来进程C的操作需要用到资源B，进程D的操作需要用到资源A

* 但是C、D都得不到资源，就引发了死锁

*/

class Lock{

static Object lockOne = new Object();//资源A

static Object lockTwo = new Object();//资源B

}

class ThreadLock implements Runnable{

private boolean flag;

public ThreadLock(boolean flag){

this.flag = flag;

}

@Override

public void run() {

if(flag){

while (true) {

synchronized (Lock.lockOne) {

System.out.println(" this is lockOne");

synchronized (Lock.lockTwo) {

System.out.println("this is lockTwo");

}

}

}

}else {

while (true) {

synchronized (Lock.lockTwo) {

System.out.println(" 这是 lockTwo");

synchronized (Lock.lockOne) {

System.out.println("这是 lockOne");

}

}

}

}

}

}