body, table{font-family: 微软雅黑; font-size: 13.5pt}
table{border-collapse: collapse; border: solid gray; border-width: 2px 0 2px 0;}
th{border: 1px solid gray; padding: 4px; background-color: #DDD;}
td{border: 1px solid gray; padding: 4px;}
tr:nth-child(2n){background-color: #f8f8f8;}

test2.java Ticket.java
package com.java.homework2;
public class test2 {
/*     1.将之前的三个窗口修改为一个窗口买票。
        2.新增加一个退票窗口。
        3.将需求修改为当前所有速7的票都已经卖光了，如果窗口想卖票只有等待退票窗口有一张退票之后，售票窗口才可以买出。*/
        public static void main(String[] args) {
                Ticket ticket=new Ticket(10);
                RefundTicket refundTicket=new RefundTicket(ticket);
                SellTickets selltickets=new SellTickets(ticket);
                Thread t1=new Thread(refundTicket);
                Thread t2=new Thread(selltickets);
                t2.start();
                t1.start();
        }
}
package com.java.homework2;
public class Ticket {
        public int number;
        public Ticket(int number){
                this.number=number;
        }
}
SellTickets.java RefundTicket.java
package com.java.homework2;
public class SellTickets implements Runnable{
        Ticket ticket;
        public SellTickets(Ticket ticket){
                this.ticket=ticket;
        }
        public void run() {
                while(true){
                        try {
                                Thread.sleep(500);    //都用Thread调用
//这些方法都是Object类里面的，Thread类继承了Object类
                        } catch (InterruptedException e1) {
                                e1.printStackTrace();
                        }
                        synchronized(ticket){                       
                                if(ticket.number<=0||ticket.number>10){
                                        try {
                                                ticket.wait();
                                        } catch (InterruptedException e) {
                                                e.printStackTrace();
                                        }
                                }
                                        System.out.println("卖出第 "+ticket.number+" 张票");
                                        ticket.number--;
                                        ticket.notify();                       
                                }
                        }
                }
}
package com.java.homework2;
public class RefundTicket implements Runnable {
        Ticket ticket;
        public RefundTicket(Ticket ticket) {
                this.ticket = ticket;
        }
        public void run() {
                while (true) {
                        try {
                                Thread.sleep(1000);        //都用Thread调用
                        } catch (InterruptedException e1) {
                                e1.printStackTrace();
                        }
                        synchronized (ticket) {
                                if (ticket.number ==10||ticket.number<0) {
                                        try {
                                                ticket.wait();
                                        } catch (InterruptedException e) {
                                                e.printStackTrace();
                                        }
                                }
                                        ticket.number++;
                                        System.out.println("收到第 " + ticket.number + " 张退票");
                                        ticket.notify();
                                }
                        }
                }
}

test3.java Flag.java
package com.java.homework3;
/*创建2个线程，每个线程都打印从0到99这100个数字，
* 线程之间不会出现交叉乱序打印，而是顺序地打印。*/
public class test3 {
        public static void main(String[] args) {
                Flag fl=new Flag();
                print1 p1=new print1("No1.",fl);
                print2 p2=new print2("No2.",fl);
                Thread t1=new Thread(p1);
                Thread t2=new Thread(p2);
                t1.start();
                t2.start();
        }
}
package com.java.homework3;
public class Flag {
        public boolean flag;   //控制交叉打印
        public int num=0;      //控制打印的数
}
print1.java print2.java
package com.java.homework3;
public class print1 implements Runnable {
        String nameString = Thread.currentThread().getName();
        Flag flag;
        public print1(String nameString, Flag flag) {
                this.nameString = nameString;
                this.flag = flag;
        }
        public void run() {
                while (true) {
                        synchronized (flag) {
                                if (flag.flag) {
                                        try {
                                                flag.wait();
                                        } catch (InterruptedException e) {
                                                e.printStackTrace();
                                        }
                                }
                                if (flag.num <= 100) {
                                        System.out.println(nameString + "这是第 " + flag.num + " 个数");
                                        flag.num++;
                                }
                                flag.notify();
                                flag.flag = true;
                        }
                }
        }
}
package com.java.homework3;
public class print2 implements Runnable {
        String nameString;
        Flag flag;
        public print2(String nameString, Flag flag) {
                this.nameString = nameString;
                this.flag = flag;
        }
        public void run() {
                while (true) {
                        synchronized (flag) {
                                if (!flag.flag) {
                                        try {
                                                flag.wait();
                                        } catch (InterruptedException e) {
                                                e.printStackTrace();
                                        }
                                }
                                if (flag.num <= 100) {
                                        System.out.println(nameString + "这是第 " + flag.num + " 个数");
                                        flag.num++;
                                }
                                flag.notify();
                                flag.flag = false;
                        }
                }
        }
}

test4.java Bullet.java
package com.java.homework4;
/**
* 3、采用Java 多线程技术，设计实现一个符合生产者和消费者问题的程序。
* 对一个对象（枪膛）进行操作，其最大容量        是1颗子弹。
* 生产者线程是一个压入线程，它不断向枪膛中压入子弹；消费者线程是一个射出线程，它不断从枪膛中射出子弹。  
* 要求：    （1）给出分析过程说明。    
* （提示：这是个生产者与消费者问题，也是线程的同步问题，
*  为了防止两个线程访问一个资源时出现忙等待，要使用的wait-notify函数，是两个线程交替执行; ）  
* （2）程序输出，要模拟体现对枪膛的压入和射出操作；   
* （3）设计程序时应考虑到两个线程的同步问题。
*/
public class test4 {
        public static void main(String[] args) {
                Bullet bullet=new Bullet();
                AddBullet ab=new AddBullet(bullet);
                ShootBullet sb=new ShootBullet(bullet);
                Thread t1=new Thread(ab);
                Thread t2=new Thread(sb);
                t1.start();
                t2.start();
        }
}
package com.java.homework4;
public class Bullet {
        public boolean flag;  //控制是否有子弹
}
AddBullet.java ShootBullet.java
package com.java.homework4;
public class AddBullet implements Runnable{
        public Bullet bullet;
        public AddBullet(Bullet bullet){
                this.bullet=bullet;
        }
        public void run() {
                while(true){
                        synchronized(bullet){
                                if(bullet.flag){
                                        try {
                                                bullet.wait();
                                        } catch (InterruptedException e) {
                                                e.printStackTrace();
                                        }
                                }
                                try {
                                        Thread.sleep(1000);
                                } catch (InterruptedException e) {
                                        e.printStackTrace();
                                }
                                System.out.println("子弹上膛~~~~");
                                bullet.notify();
                                bullet.flag=true;
                        }
                }
        }
}
package com.java.homework4;
public class ShootBullet implements Runnable{
        public Bullet bullet;
        public ShootBullet(Bullet bullet){
                this.bullet=bullet;
        }
        public void run() {
                while(true){
                        synchronized(bullet){
                                if(!bullet.flag){
                                        try {
                                                bullet.wait();
                                        } catch (InterruptedException e) {
                                                e.printStackTrace();
                                        }
                                }
                                try {
                                        Thread.sleep(1000);
                                } catch (InterruptedException e) {
                                        e.printStackTrace();
                                }
                                System.out.println("射击！！！");
                                bullet.notify();
                                bullet.flag=false;
                        }
                }
        }
}
test5.java
/*手动新建一个计时器，并且自己创建一个任务。然后尝试使用如下定时器在固定的时间内去执行你想要到任务。
void schedule(TimerTask task, Date time)
          安排在指定的时间执行指定的任务。
void schedule(TimerTask task, Date firstTime, long period)
          安排指定的任务在指定的时间开始进行重复的固定延迟执行。
void schedule(TimerTask task, long delay)
          安排在指定延迟后执行指定的任务。
void schedule(TimerTask task, long delay, long period)
          安排指定的任务从指定的延迟后开始进行重复的固定延迟执行。
void scheduleAtFixedRate(TimerTask task, Date firstTime, long period)
          安排指定的任务在指定的时间开始进行重复的固定速率执行。
void scheduleAtFixedRate(TimerTask task, long delay, long period)
          安排指定的任务在指定的延迟后开始进行重复的固定速率执行。
*/
public class test5 {
        public static void main(String[] args) {
                Timer timer=new Timer();
                Mytask mytask=new Mytask();
                Date date=new Date();
                GregorianCalendar c1=new GregorianCalendar(2017,2,18,14,60,40);  //月份默认从0开始
                //GregorianCalendar 是 Calendar 的一个具体子类，提供了世界上大多数国家/地区使用的标准日历系统。
                //GregorianCalendar(int year, int month, int dayOfMonth, int hourOfDay, int minute, int second) ;
                date=c1.getTime();  //这个方法是夫类的，子类继承了夫类，所以也能调用

 //Date getTime();  //返回一个表示此 Calendar 时间值（从历元至现在的毫秒偏移量）的 Date 对象

                System.out.println(date);
                timer.scheduleAtFixedRate(mytask, date, 3000);
        }
}
class Mytask extends TimerTask{
        public void run() {
                System.out.println("Mytask.run()");
        }
}

这个时间要设置成运行程序的时间往后，不然会执行好多次Mytask的任务；设置成运行程序时间之后，run方法会在到时间开始执行

Java——多线程练习的更多相关文章

  1. 40个Java多线程问题总结

    前言 Java多线程分类中写了21篇多线程的文章,21篇文章的内容很多,个人认为,学习,内容越多.越杂的知识,越需要进行深刻的总结,这样才能记忆深刻,将知识变成自己的.这篇文章主要是对多线程的问题进行 ...

  2. Java多线程基础知识篇

    这篇是Java多线程基本用法的一个总结. 本篇文章会从一下几个方面来说明Java多线程的基本用法: 如何使用多线程 如何得到多线程的一些信息 如何停止线程 如何暂停线程 线程的一些其他用法 所有的代码 ...

  3. Java多线程系列--“JUC锁”03之 公平锁(一)

    概要 本章对“公平锁”的获取锁机制进行介绍(本文的公平锁指的是互斥锁的公平锁),内容包括:基本概念ReentrantLock数据结构参考代码获取公平锁(基于JDK1.7.0_40)一. tryAcqu ...

  4. Java多线程系列--“JUC锁”04之 公平锁(二)

    概要 前面一章,我们学习了“公平锁”获取锁的详细流程:这里,我们再来看看“公平锁”释放锁的过程.内容包括:参考代码释放公平锁(基于JDK1.7.0_40) “公平锁”的获取过程请参考“Java多线程系 ...

  5. Java多线程--让主线程等待子线程执行完毕

    使用Java多线程编程时经常遇到主线程需要等待子线程执行完成以后才能继续执行,那么接下来介绍一种简单的方式使主线程等待. java.util.concurrent.CountDownLatch 使用c ...

  6. Java多线程 2 线程的生命周期和状态控制

    一.线程的生命周期 线程状态转换图: 1.新建状态 用new关键字和Thread类或其子类建立一个线程对象后,该线程对象就处于新生状态.处于新生状态的线程有自己的内存空间,通过调用start方法进入就 ...

  7. java 多线程 1 线程 进程

    Java多线程(一).多线程的基本概念和使用 2012-09-10 16:06 5108人阅读 评论(0) 收藏 举报  分类: javaSE综合知识点(14)  版权声明:本文为博主原创文章,未经博 ...

  8. 一起阅读《Java多线程编程核心技术》

    目录 第一章 Java多线程技能 (待续...)

  9. 第一章 Java多线程技能

    1.初步了解"进程"."线程"."多线程" 说到多线程,大多都会联系到"进程"和"线程".那么这两者 ...

  10. java从基础知识（十）java多线程（下）

    首先介绍可见性.原子性.有序性.重排序这几个概念 原子性:即一个操作或多个操作要么全部执行并且执行的过程不会被任何因素打断,要么都不执行. 可见性:一个线程对共享变量值的修改,能够及时地被其它线程看到 ...

随机推荐

  1. Linux-进程间的通信-信号集函数【转】

    我们已经知道,我们可以通过信号来终止进程,也可以通过信号来在进程间进行通信,程序也可以通过指定信号的关联处理函数来改变信号的默认处理方式,也可以屏蔽某些信号,使其不能传递给进程.那么我们应该如何设定我 ...

  2. POJ 1751 Highways（最小生成树&Prim）题解

    思路: 一开始用Kruskal超时了,因为这是一个稠密图,边的数量最惨可能N^2,改用Prim. Prim是这样的,先选一个点(这里选1)作为集合A的起始元素,然后其他点为集合B的元素,我们要做的就是 ...

  3. The equation （扩展欧几里得）题解

    There is an equation ax + by + c = 0. Given a,b,c,x1,x2,y1,y2 you must determine, how many integer r ...

  4. spring与spring-data-redis整合redis

    <?xml version="1.0" encoding="UTF-8"?> <beans xmlns="http://www.sp ...

  5. C# string[]转List<string>

    List<string> ltProduct = new List<string>(Product.Split('|'));

  6. BZOJ 1758 【WC2010】 重建计划

    题目链接:重建计划 这道题现在已经成为一道板子题了…… 这是个非常显然的0-1分数规划,可以二分答案之后树分治判定一下.注意树分治的时候如果使用单调队列,需要把所有儿子预先按最大深度排好序,否则会被扫 ...

  7. 使用uWSGI和nginx来设置Django和你的web服务器

    本教程针对那些想要设置一个生产web服务器的Django用户.它介绍了设置Django以使得其与uWSGI和nginx工作良好的必要步骤.它涵盖了所有三个组成部分,提供了一个web应用和服务器软件的完 ...

  8. [ios][map]自定义地图标注

    参考:http://blog.csdn.net/mad1989/article/details/8794762 ios 一步一步学会自定义地图吹出框(CalloutView)-->(百度地图,高 ...

  9. webpack和tree shaking和rollup

    http://blog.csdn.net/haodawang/article/details/77199980 tree shaking只对es模块生效,在打包tyscript模块是要使用tsc编译器 ...

  10. Greedy Subsequences CodeForces - 1132G

    我们从右往左滑动区间, 假设dp[i]表示i为左端点时的最大长度, 通过观察可以发现, 每添加一个点, 该点$dp$值=它右侧第一个比它大位置处$dp$值+1, 但是每删除一个点会将所有以它为根的$d ...

热门专题

reid rank-1中文
mysql update 会新增吗
map之间 foldleft
vue rule数组校验
input 修改name
kendo UI界面布局
使用HAL_delay后卡死
更新gcc7 ubuntu16.04
spingbatch基于游标
C# 一些实用的功能
vscode vim 自动切换英文
apollo X项目
请求header加参数时间戳的意义
R语言legend.justification
tp5 extends 外部函数
phpmyadmin修改root密码后进不去
conda添加镜像源bioconda
jboss7日志配置
nginx location内js expires
unity手动打包成asset