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. UDP的socketasynceventargs

    C# 使用 SocketAsyncEventArgs 实现UdpSocket系列 http://www.cnblogs.com/zwq194/archive/2012/10/30/2746393.ht ...

  2. Unity3D学习笔记（十二）：2D模式和异步资源加载

    2D模式和3D模式区别:背景纯色,摄像机2D,没有深度轴 精灵图片设置 Normal map,法线贴图,更有立体感 Sprite (2D and UI),2D精灵贴图,有两种用途 1.当做UI贴图 2 ...

  3. Pytorch版本yolov3源码阅读

    目录 Pytorch版本yolov3源码阅读 1. 阅读test.py 1.1 参数解读 1.2 data文件解析 1.3 cfg文件解析 1.4 根据cfg文件创建模块 1.5 YOLOLayer ...

  4. 【TCP/IP详解 卷一：协议】第十一章 UDP 用户数据报协议

    11.1 引言 UDP 是一个简单的 面向数据报 的运输层协议:进程的每个 输出操作 都正好产生一个 UDP数据报,并且组装成一份待发送的IP数据报. 这与 TCP 不一样,它是 面向流字符 的协议, ...

  5. IIS Express 配置json minitype

    IIS Express 配置json minitype 1.在命令窗口中cd到IIS Express安装目录,默认是“C:\Program Files\IIS Express”: 2.在IIS Exp ...

  6. java ShutdownHook介绍与使用

    Java程序经常也会遇到进程挂掉的情况,一些状态没有正确的保存下来,这时候就需要在JVM关掉的时候执行一些清理现场的代码.JAVA中的ShutdownHook提供了比较好的方案. JDK提供了Java ...

  7. Python中通过csv的writerow输出的内容有多余的空行

    第一种方法 如下生成的csv文件会有多个空行 import csv #python2可以用file替代open with open("test.csv","w" ...

  8. Codeforces 918C - The Monster

    918C - The Monster 思路1: 右键在新窗口打开图片 代码: #include<bits/stdc++.h> using namespace std; #define ll ...

  9. Lua中元表的学习

    --table 中我们可以访问对应的key来得到value值,但是却无法对两个 table 进行操作. --元表(Metatable),允许我们改变table的行为,可以对两个table进行操作 -- ...

  10. [.NET开发] C#实现的SQL备份与还原功能示例

    本文实例讲述了C#实现的SQL备份与还原功能.分享给大家供大家参考,具体如下: //记得加 folderBrowserDialog1 openFileDialog1 控件 using System.D ...

热门专题

Horizon view 通过microsoft rdp登录
css按钮的四种状态
K-Menas转灰度图
find_and_output_chorus不能提取纯音乐
神舟笔记本CONTROL CENTER
deepin出现busybox
decode的sql用法
小程序页面加载时接口传数据给子组件
oracle获取json字段的某个属性值
mac oracle vm virtualbox 分辨率
python 内部类调用外部类属性
centso7.6 安装中文字体
enumerate 计数器 latex
plots 风格样式
kotlin operator和overwrite
因子分析权数法FAM
winsock senddata 立即发送
部署站点文件与git同步
svn和github
电脑不能ping其他电脑