实现线程的方式是一,继承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");
}
}
}
}
} }

java 多线程简单例子的更多相关文章

  1. python多线程简单例子

    python多线程简单例子 作者:vpoet mail:vpoet_sir@163.com import thread def childthread(threadid): print "I ...

  2. C#多线程简单例子讲解

    C#多线程简单例子讲解 标签: 多线程c#threadobjectcallbacktimer 分类: C#(7) 转载网址:http://www.knowsky.com/540518.html .NE ...

  3. java多线程(简单介绍)

    简单介绍 线程是程序运行的基本执行单元.当操作系统(不包括单线程的操作系统,如微软早期的DOS)在执行一个程序时,会在系统中建立一个进程,而在这个进程中,必须至少建立一个线程(这个线程被称为主线程)来 ...

  4. Java RMI简单例子HelloWorld

    Java RMI 指的是远程方法调用 (Remote Method Invocation).它是一种机制,能够让在某个 Java 虚拟机上的对象调用另一个 Java 虚拟机中的对象上的方法.可以用此方 ...

  5. 【多线程】java多线程 测试例子 详解wait() sleep() notify() start() join()方法 等

    java实现多线程,有两种方法: 1>实现多线程,继承Thread,资源不能共享 2>实现多线程  实现Runnable接口,可以实现资源共享 *wait()方法 在哪个线程中调用 则当前 ...

  6. QT多线程简单例子

    在Qt中实现多线程,除了使用全局变量.还可以使用信号/槽机制. 以下例子使用信号/槽机制. 功能: 在主线程A界面上点击按钮,然后对应开起一个线程B.线程B往线程A发送一个字符串,线程A打印出来. 1 ...

  7. Python Threading多线程简单例子

    业务监控,多线程例子,实现每类个监控项的不同监控间隔. #coding=utf-8import sysimport pymysqlimport osfrom prometheus_client imp ...

  8. Java——多线程小例子

    body, table{font-family: 微软雅黑; font-size: 10pt} table{border-collapse: collapse; border: solid gray; ...

  9. java grpc简单例子

    原文地址:http://blog.csdn.net/jek123456/article/details/53465033 用eclipse新建一个maven项目,Id信息如下 <groupId& ...

随机推荐

  1. CASUAL_NCT

    using System; using System.Collections.Generic; using System.Linq; using System.Web; using System.Da ...

  2. sql-向已有数据的表添加约束

    语法: alter table 表名 with nocheck add constraint 约束名 约束类型 具体的约束说明 对表中现有的数据不做检查, 只对添加约束后再录入的数据进行检查. 例子: ...

  3. WHU1124 Football Match

    http://acm.whu.edu.cn/learn/problem/detail?problem_id=1124 题目大意:有N支球队,你们是第N支.每个队伍已经有一些分数了,接下来还有M场比赛. ...

  4. 一个可遇不可求的 bug 全局变量初始化顺序问题 哈哈

    这是今天下午帮同事查的一个客户端 C++ 的 bug,前人留下的谜之代码.. 具体情况是,客户端实现了有一个简单的内存池,每次申请内存的时候会把新申请到的内存信息存到一个 map 里,据说是为了检查内 ...

  5. 聊聊fetch

    fetch的使用 fetch是一个发起异步请求的新api, 在浏览器(有些不支持)中可以直接使用. Promise fetch(url, init) fetch接收两个参数,第一个参数是请求路径,第二 ...

  6. Struts2再爆远程命令执行漏洞![W3bSafe]Struts2-048 Poc Shell及防御修复方案抢先看!

    漏洞概述 Apache Struts是美国阿帕奇(Apache)软件基金会负责维护的一个开源项目,是一套用于创建企业级Java Web应用的开源MVC框架.在Struts 2.3.x 系列的 Show ...

  7. 开发微信小程序——古龙小说阅读器

    概述 由于面试的关系接触了一下微信小程序,花了2晚上开发了一个带书签功能的古龙小说阅读器,并且已经提交审核等待发布.这篇博文记录了我的开发过程和对微信小程序的看法,供以后开发时参考,相信对其他人也有用 ...

  8. Java学习笔记37(字节流)

    输出:程序到文件 输入:文件到程序 字节输出流:OutputStream类 作用:在java程序中写文件 这个类是抽象类,必须使用它的子类 方法: 写入: package demo; import j ...

  9. 精通Linux

    1, linux 启动流程,详细 2,grub , grub2 3, 文件系统,不同文件系统的特性 ext3 , ext 4 ,xfs 4, 不同目录的作用, 分区 5,用户管理 6,文件权限,目录挂 ...

  10. WebMvcConfigurer

    [传送门]:详解WebMvcConfigurer接口 1. 设置跨域规则 @Configuration public class CrossOriginConfig implements WebMvc ...