/*
* Timer类是一种线程设施,可以用来实现在某一个时间或某一段时间后安排某一个任务执行一次或定期重复执行.
* Timer类的常用方法
* 1>Timer()创建一个计时器,并启动该计时器
* 2>cancel()取消计时器
* 3>purge()将已取消的任务移除,用来释放内存空间
* 4>schedule()安排一个任务执行
* TimerTask类的常用方法
* 1>cancel()
* 2>run()
* 3>scheduled Execution Time()
*/
package com.timer;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.Timer;
import java.util.TimerTask;
public class timer {
public static void main(String[] args){
myTast mytast = new myTast();
Timer t = new Timer();
t.schedule(mytast, 1000, 1000);
}
}
/*
* 设计时钟类
*/
class myTast extends TimerTask{
private static int time;
public myTast(){
this.time=0;
}
@Override
public void run() {
// TODO Auto-generated method stub
if(this.time>2){
this.cancel(); //执行两次后终止,第三次会执行完
}else{
this.time++;
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss.SSS");
String time = sdf.format(new Date());
System.out.println(time+"=>"+this.time);
}
}
}
-
java定时任务与spring_Java定时任务调度器Quartz与Spring集成
2021-03-11 10:56:49Quartz是Java中比较成熟和常用的任务调度器。Spring框架对其提供了集成。Quartz非常容易使用。一个任务调度器最基本的三个元素是Job(or Task):需要定时处理的事情Trigger: 事件触发时间点(一次性的、固定周期性的、...在项目中经常有定时任务的功能需求。Quartz是Java中比较成熟和常用的任务调度器。Spring框架对其提供了集成。Quartz非常容易使用。
一个任务调度器最基本的三个元素是
Job(or Task):需要定时处理的事情
Trigger: 事件触发时间点(一次性的、固定周期性的、像Linux Cron Jobs 灵活配置的)
Scheduler: 调度器
Job与Trigger是一对一的关系,Scheduler与Trigger是一对多的关系。
先看一个Spring配置这三个元素的示例:
Cron表达式使用格式
Seconds
Minutes
Hours
DayofMonth
Month
DayofWeek
[Year]
秒
分
时
天
月
星期
[年]
每个符号代表的含义:
* :匹配该域的任意值;如*用在分所在的域,表示每分钟都会触发事件。
? :匹配该域的任意值。
– :匹配一个特定的范围值;如时所在的域的值是10-12,表示10、11、12点的时候会触发事件。
, :匹配多个指定的值;如周所在的域的值是2,4,6,表示在周一、周三、周五就会触发事件(1表示周日,2表示周一,3表示周二,以此类推,7表示周六)。
/ :左边是开始触发时间,右边是每隔固定时间触发一次事件,如秒所在的域的值是5/15,表示5秒、20秒、35秒、50秒的时候都触发一次事件。
L :last,最后的意思,如果是用在天这个域,表示月的最后一天,如果是用在周所在的域,如6L,表示某个月最后一个周五。(外国周日是星耀日,周一是月耀日,一周的开始是周日,所以1L=周日,6L=周五。)
W :weekday,工作日的意思。如天所在的域的值是15W,表示本月15日最近的工作日,如果15日是周六,触发器将触发上14日周五。如果15日是周日,触发器将触发16日周一。如果15日不是周六或周日,而是周一至周五的某一个,那么它就在15日当天触发事件。
# :用来指定每个月的第几个星期几,如6#3表示某个月的第三个星期五。
实用的例子
表达式
含义
“0 0 12 * * ?”
每天12:00触发事件
“0 15 10 ? * *”
每天10:15触发事件
“0 15 10 * * ?”
每天10:15触发事件
“0 15 10 * * ? *”
每天10:15触发事件
“0 15 10 * * ? 2005”
2005年的每天10:15触发事件
“0 * 14 * * ?”
每天14点开始触发,每分钟触发一次,14:59分结束
“0 0/5 14 * * ?”
每天14点开始触发到14:59分结束的每5分钟触发一次事件
“0 0/5 14,18 * * ?”
每天14点开始到14:59期间和18点到18:59期间的每5分钟触发一次事件
“0 0-5 14 * * ?”
每天14点到14:05期间的每1分钟触发一次事件
“0 10,44 14 ? 3 WED”
每年3月的星期三的14:10和14:44触发一次事件
“0 15 10 ? * MON-FRI”
周一至周五的10:15触发一次事件
“0 15 10 15 * ?”
每月15日10:15触发一次事件
“0 15 10 L * ?”
每月最后一日的10:15触发一次事件
“0 15 10 ? * 6L”
每月的最后一个星期五10:15触发一次事件
“0 15 10 ? * 6L 2002-2005”
2002年至2005年的每月的最后一个星期五10:15触发一次事件
“0 15 10 ? * 6#3”
每月的第三个星期五10:15触发一次事件
-
Java中使用Quartz进行任务调度常用操作
2017-12-03 12:48:46包含Java中使用Quartz进行任务调度常用操作:设置开始时间、设置结束时间、简单触发器、Cron触发器、作业监听器、启动多个作业、查看所有作业、手动触发作业、传递参数、取消/删除作业、作业出错时自动再执行等代码... -
java定时调度
2014-01-27 13:21:25* Timer类的常用方法 * 1>Timer()创建一个计时器,并启动该计时器 * 2>cancel()取消计时器 * 3>purge()将已取消的任务移除,用来释放内存空间 * 4>schedule()安排一个任务执行 ...转载于:https://blog.51cto.com/6846041/1355031
-
java常用类库续3(比较器Comparable、Comparator、观察者设计模式、正则表达式、定时调度)
2014-08-20 20:57:25比较器(Comparable、Comparator) Comparable接口 可以直接使用java.util.Arrays类进行数组的排序操作,但对象所在的类必须实现Comparable接口,用于指定排序接口。 Comparable接口定义如下: [java] ...比较器(Comparable、Comparator)
Comparable接口
可以直接使用java.util.Arrays类进行数组的排序操作,但对象所在的类必须实现Comparable接口,用于指定排序接口。
Comparable接口定义如下:
- public interface Comparable<T>{
- public int compareTo(T o);
- }
从接口的定义格式上来看,可以发现如果想实现对象属性的排序功能,要实现Comparable接口,并且覆写compareTo(T o)方法。此方法返回的是一个int类型的数据,但是此int类型的数据只能是一下三种:
·1:表示大于
·-1:表示小于
·0:表示等于
看如下的实例:一个学生类,里面有三个属性姓名、年龄、成绩三个属性,要求按成绩由高到底排序,如果成绩相等,则按照年龄由底到高排序。
- class Student implements Comparable<Student> //指定类型为Student
- {
- private String name;
- private int age;
- private float score;
- public Student(String name,int age,float score){
- this.name=name;
- this.age=age;
- this.score=score;
- }
- public String toString(){
- return name+"\t\t"+age+"\t\t"+score+"\t\t";
- }
- public int compareTo(Student stu){ //覆写compareTo方法,实现排序规则的应用
- if(this.score<stu.score){
- return -1;
- }
- if(this.score>stu.score){
- return 1;
- }
- else{
- if(this.age<stu.age){
- return -1;
- }
- if(this.age>stu.age){
- return 1;
- }
- else{
- return 0;
- }
- }
- }
- }
- public class ComparableDemo01
- {
- public static void main(String args[]){
- Student stu[]={
- new Student("张三",20,89.1f),
- new Student("李四",26,53.5f),
- new Student("王五",30,79.0f),
- new Student("赵六",20,66.0f),
- new Student("孙七",25,66.0f)
- };
- java.util.Arrays.sort(stu); //进行排序操作
- for(Student x:stu){ //循环输出
- System.out.println(x);
- }
- }
- }
注意:如果在此时Student类没有实现Comparable接口,则在执行的时候会出现一下异常:
- Exception in thread "main" java.lang.ClassCastException: Student cannot be cast
- to java.lang.Comparable
另一种比较器Comparator
此比较器其实跟Comparable是非常类似的。如果现在已经完成了一个类的开发,但是并没有实现Comparable接口,此时肯定是无法进行对象排序操作的,所以为了解决这种问题,java又定义了另一个比较器的操作接口---Comparator。此接口在java.util包中,接口如下定义:
- pubic interface Comparator<T>{
- public int compare(T o1,T o2);
- boolena equals(Object obj);
- }
代码如下:
- import java.util.*;
- class Student {
- private String name;
- private int age;
- private float score;
- public Student(String name,int age,float score){
- this.name=name;
- this.age=age;
- this.score=score;
- }
- public void setName(String name){
- this.name=name;
- }
- public String getName(){
- return name;
- }
- public void setAge(int age){
- this.age=age;
- }
- public int getAge(){
- return age;
- }
- public String toString(){
- return name+"\t\t"+age+"\t\t"+score+"\t\t";
- }
- }
- class StudentComparator implements Comparator<Student>
- {
- //因为Object类中已经覆写过equals方法
- public int compare(Student s1,Student s2){
- if(s1.equals(s2)){
- return 0;
- }
- else if(s1.getAge()<s2.getAge()){ //按照年龄进行比较
- return 1;
- }
- else{
- return -1;
- }
- }
- }
- public class ComparableDemo02
- {
- public static void main(String args[]){
- Student stu[]={
- new Student("张三",20,89.1f),
- new Student("李四",26,53.5f),
- new Student("王五",30,79.0f),
- new Student("赵六",20,66.0f),
- new Student("孙七",25,66.0f)
- };
- java.util.Arrays.sort(stu,new StudentComparator()); //进行排序操作
- for(Student x:stu){ //循环输出
- System.out.println(x);
- }
- }
- }
总结:在开发中尽量还是使用Comparable在需要排序的类上实现好此接口,而Comparator需要单独建立一个排序的类,这样如果有很多的话,则排序的规则类也就会很多,操作起来比较麻烦些。注意:在java中只要是对象排序,永远都是以Comparable接口为准的。
观察者设计模式
具体内容
所谓观察者设计模式,就是某一样东西被多个观察者观察,当这样东西发生变化,则会及时反馈到每个观察者的身上。如果要想实现观察者设计模式,则必须依靠java.util包中的Observable类和Observer接口。
例子:现在很多的购房者都在关注着房子的变化,每当房子价格变化的时候,所有的观察者都能够立即观察到
- import java.util.* ;
- class House extends Observable{ // 表示房子可以被观察
- private float price ;// 价钱
- public House(float price){
- this.price = price ;
- }
- public float getPrice(){
- return this.price ;
- }
- public void setPrice(float price){
- // 每一次修改的时候都应该引起观察者的注意
- super.setChanged() ; // 设置变化点
- super.notifyObservers(price) ;// 价格被改变
- this.price = price ;
- }
- public String toString(){
- return "房子价格为:" + this.price ;
- }
- };
- class HousePriceObserver implements Observer{
- private String name ;
- public HousePriceObserver(String name){ // 设置每一个购房者的名字
- this.name = name ;
- }
- public void update(Observable o,Object arg){
- if(arg instanceof Float){
- System.out.print(this.name + "观察到价格更改为:") ;
- System.out.println(((Float)arg).floatValue()) ;
- }
- }
- };
- public class ObserDemo01{
- public static void main(String args[]){
- House h = new House(1000000) ;
- HousePriceObserver hpo1 = new HousePriceObserver("购房者A") ;
- HousePriceObserver hpo2 = new HousePriceObserver("购房者B") ;
- HousePriceObserver hpo3 = new HousePriceObserver("购房者C") ;
- h.addObserver(hpo1) ;
- h.addObserver(hpo2) ;
- h.addObserver(hpo3) ;
- System.out.println(h) ; // 输出房子价格
- h.setPrice(666666) ; // 修改房子价格
- System.out.println(h) ; // 输出房子价格
- }
- };
正则表达式
正则表达式可以方便的对数据进行匹配,可以执行更加复杂的字符串验证、拆分、替换等功能。
例如:现在要求判断一个字符串是否由数字组成,有以下两种方式:
·不使用正则完成
·使用正则完成
第一种方式代码:
- public class RegexDemo01{
- public static void main(String args[]){
- String str = "1234567890" ; // 此字符串由数字组成
- boolean flag = true ; // 定义一个标记变量
- // 要先将字符串拆分成字符数组,之后依次判断
- char c[] = str.toCharArray() ; // 将字符串变为字符数组
- for(int i=0;i<c.length;i++){ // 循环依次判断
- if(c[i]<'0'||c[i]>'9'){ // 如果满足条件,则表示不是数字
- flag = false ; // 做个标记
- break ; // 程序不再向下继续执行
- }
- }
- if(flag){
- System.out.println("是由数字组成!") ;
- }else{
- System.out.println("不是由数字组成!") ;
- }
- }
- };
第二中方式代码:
- import java.util.regex.Pattern ;
- public class RegexDemo02{
- public static void main(String args[]){
- String str = "1234567890" ; // 此字符串由数字组成
- if(Pattern.compile("[0-9]+").matcher(str).matches()){ // 使用正则
- System.out.println("是由数字组成!") ;
- }else{
- System.out.println("不是由数字组成!") ;
- }
- }
- };
Pattern、Matcher类
这两个类为正则的核心操作类,都是定义在java.util.regex包中。Pattern类主要是进行正则规范(如之前的操作“[0-9]“就属于正则规范)的编写,而Matcher类主要是执行规范,验证一个字符串是否符合规范。
常用正则规则:
·\d:表示数字, [0-9]
·\D:表示非数字,[^0-9]
·\w:表示字母、数字、下划线,[a-zA-Z0-9]
·\W:[^a-zA-Z0-9]
常用正则规范2:
以上的正则,如果要想驱动起来,则必须依靠Pattern和Matcher类。
Pattern主要是表示一个规则的意思,即:正则表达式的规则需要在Pattern类中使用。
Matcher类主要表示使用Pattern指定好的规则验证。
Pattern类的常用方法:
方法
描述
public static Pattern compile(String regex)
指定正则表达式规则
public Matcher matcher(CharSequence input)
返回Mather类的实例
public String[] split(CharSequence input)
字符串拆分
在Patter类中如果要想取得Pattern类的实例,则必须调用compile()方法。
本类中没有明确的构造方法可以使用,那么此类的构造方法肯定被私有化了,如果是这样的类,都可以通过本类中的一个静态方法获得该类的实例。
Matcher类中的常用方法:
方法
描述
Public Boolean matches()
执行验证
Public String replaceAll(String replacement)
字符串替换
实例操作:(验证日期是否合法)
- import java.util.regex.Pattern ;
- import java.util.regex.Matcher ;
- public class RegexDemo03{
- public static void main(String args[]){
- String str = "1983-07-27" ; // 指定好一个日期格式的字符串
- String pat = "\\d{4}-\\d{2}-\\d{2}" ; // 指定好正则表达式
- Pattern p = Pattern.compile(pat) ; // 实例化Pattern类
- Matcher m = p.matcher(str) ; // 实例化Matcher类
- if(m.matches()){ // 进行验证的匹配,使用正则
- System.out.println("日期格式合法!") ;
- }else{
- System.out.println("日期格式不合法!") ;
- }
- }
- };
在Pattern类中也可以使用正则进行字符的拆分功能:
- import java.util.regex.Pattern ;
- import java.util.regex.Matcher ;
- public class RegexDemo04{
- public static void main(String args[]){
- // 要求将里面的字符取出,也就是说按照数字拆分
- String str = "A1B22C333D4444E55555F" ; // 指定好一个字符串
- String pat = "\\d+" ; // 指定好正则表达式
- Pattern p = Pattern.compile(pat) ; // 实例化Pattern类
- String s[] = p.split(str) ; // 执行拆分操作
- for(int x=0;x<s.length;x++){
- System.out.print(s[x] + "\t") ;
- }
- }
- };
还可以使用Matcher类中的字符串替换功能:
- import java.util.regex.Pattern ;
- import java.util.regex.Matcher ;
- public class RegexDemo05{
- public static void main(String args[]){
- // 要求将里面的字符取出,也就是说按照数字拆分
- String str = "A1B22C333D4444E55555F" ; // 指定好一个字符串
- String pat = "\\d+" ; // 指定好正则表达式
- Pattern p = Pattern.compile(pat) ; // 实例化Pattern类
- Matcher m = p.matcher(str) ; // 实例化Matcher类的对象
- String newString = m.replaceAll("_") ;
- System.out.println(newString) ;
- }
- };
String类对正则的支持
在String类中有以下三个方法是支持正则操作的:
方法
描述
public boolean matches(String regex)
字符串匹配
public String replaceAll(String regex,String replacement)
字符串替换
public String[] split(String regex)
字符串拆分
代码如下:
- import java.util.regex.Pattern ;
- import java.util.regex.Matcher ;
- public class RegexDemo06{
- public static void main(String args[]){
- String str1 = "A1B22C333D4444E55555F".replaceAll("\\d+","_") ;
- boolean temp = "1983-07-27".matches("\\d{4}-\\d{2}-\\d{2}") ;
- String s[] = "A1B22C333D4444E55555F".split("\\d+") ;
- System.out.println("字符串替换操作:" + str1) ;
- System.out.println("字符串验证:" + temp) ;
- System.out.print("字符串的拆分:") ;
- for(int x=0;x<s.length;x++){
- System.out.print(s[x] + "\t") ;
- }
- }
- };
但是,使用正则需要注意一点,看如下的代码:
- import java.util.regex.Pattern ;
- import java.util.regex.Matcher ;
- public class RegexDemo07{
- public static void main(String args[]){
- String info = "LXH:98|MLDN:90|LI:100" ; // 定义一个字符串
- // 拆分的形式:
- /*
- LXH --> 98
- MLDN --> 90
- LI --> 100
- */
- String s[] = info.split("\\|") ;
- System.out.println("字符串的拆分:") ;
- for(int x=0;x<s.length;x++){
- String s2[] = s[x].split(":") ;
- System.out.println(s2[0] + "\t" + s2[1]) ;
- }
- }
- };
如果有时候发现一个字符串无法按照指定的字符拆分的话,则需要使用“\”转义,转义的时候连个“\”表示一个“\”。
总结:
1、 使用正则可以方便完成字符串的验证、拆分、替换等功能。
2、 在开发中一般会使用String类提供好的正则支持,很少使用Pattern或者是Matcher类。
3、 在使用一些正则的时候,对于一些敏感的字符要进行转义。
定时调度
定时调度:每隔一段时间,程序会自动执行,成为定时调度。
如果要使用定时调度,则必须保证程序运行这才可以,也就说是相当于定时调度在程序之外又启动了一个新的线程。使用Timer和TimerTask两个类完成定时调度。
Timer类
Timer类是一种线程设施,可以用来实现在某一个时间或某一段时间后,安排某一个任务执行一次,或定期重复执行。该功能要与TimerTask类配合使用。TimerTask类用来实现由Timer安排的一次或重复执行的某一个任务。
Timer类的常用方法:
方法
类型
描述
public Timer()
构造
用来创建一个计时器并启动
public void cancel()
普通
用来终止该计时器,并放弃所有已安排的任务,对当前正在执行的任务没有影响。
public int purge()
普通
将所有已经取消的任务移除,一般用来释放内存空间
public void schedule(TimerTask task,Date time)
普通
安排一个任务在指定的时间执行,如果已经超过该时间,则立即执行。
public void scheduleAtFixedRate(TimerTask task,Date firstTime,long period)
普通
安排一个任务在指定的时间执行,之后以近似固定的频率(单位:毫秒)重复执行
Schedule()与scheduleAtFixedRate()方法的区别:
两者的区别在于重复执行任务时,对于时间间隔出现延迟的情况处理:
·Schedule()方法的执行时间间隔永远是固定的,如果之前出现了延迟的情况,之后也会按照设定好的间隔时间执行。
·scheduleAtFixedRate()方法可以根据出现的延迟时间自动调整下一次间隔的执行时间。
TimerTask类
要想执行具体的任务,则必须使用TimerTask类。TimerTask是一个抽象类,如果要使用该类,需要建立一个子类继承该类,并实现其中的抽象方法。
方法
描述
public void cancle()
用来终止此任务,如果该任务只执行一次并且还没有执行,则永远不会再执行,如果为重复执行任务,则之后不会再执行(如果该任务正在执行,则执行完后不会再执行)
public void run()
该任务所要执行的具体操作,该方法为引入接口Runable中的方法,子类需要覆写。
public long scheduledExecutionTime()
返回最近一次执行任务的时间(如果正在运行,则返回该任务的执行安排时间),一般在run()方法中调用,用来判断当前是否有足够的时间来执行完该任务。
- //完成具体的任务操作
- import java.util.*;
- import java.text.SimpleDateFormat;
- class MyTask extends TimerTask //任务调度类都要继承TimerTask
- {
- public void run(){
- SimpleDateFormat sd=new SimpleDateFormat("yyyy-MM-dd HH:mm:ss.SSS");
- System.out.println("当前系统时间为:"+sd.format(new Date()));
- }
- }
完成的是一个具体的任务操作类,以后定时调度就是调度此类的操作,方法的主体就是run()方法。注意要继承TimerTask类,下面建立测试类,并执行任务调度:
- import java.util.*;
- public class TestTask
- {
- public static void main(String args[]){
- Timer t=new Timer();
- MyTask mytask=new MyTask();
- t.schedule(mytask,1000,2000);
- }
- }
总结:一般在web开发中此内容比较有用,因为要维护一个容器不关闭才可以一直定时调度下去。
-
quartz(任务调度器)的学习
2016-11-11 11:05:18在java中我们常用Timer和TimerTask实现定时功能,而在JavaEE项目中可以使用Spring整合Quartz定时器,非常的强大,能够实现所有想要的定时任务,包括Tomcat服务器开始启动,定时定点定周等等的任务,有关Quartz的介绍...在java中我们常用Timer和TimerTask实现定时功能,而在JavaEE项目中可以使用Spring整合Quartz定时器,非常的强大,能够实现所有想要的定时任务,包括Tomcat服务器开始启动,定时定点定周等等的任务,有关Quartz的介绍和时间配置网上有很多的资料,就不在累赘,下面主要介绍SpringMVC整合Quartz的实现步骤。
来源博客: http://blog.csdn.net/fengshizty
1、 导入quartz.jar包,或者pom.xml 配置对应的依赖:
org.quartz-scheduler
quartz
1.8.6
2、 在Web项目web.xml中配置quartz的配置文件加载路径:
rest
org.springframework.web.servlet.DispatcherServlet
contextConfigLocation
/WEB-INF/classes/rest-servlet.xml,
/WEB-INF/classes/pyc-spring-quartz.xml
1
3、写具体的定时调度的任务:package andy.test.quartz.schedule;
/**
* @author Zhang,Tianyou
* @version:2014-12-11 下午12:00:24
*
* 一个测试的打印定时任务
*/public class MyPrintSchedule {
public void printSomething(){ //内容就是打印一句话 System.out.println("this is andy schedule"); }
}
4、配置quartz的xml配置信息,名字可以随便,需和web.xml中的一致。pyc-spring-quartz.xml配置信息如下:
-
java多线程方式_Java多线程之线程及其常用方法
2021-03-07 10:59:05程序运行时系统就会创建一个进程,并为它分配资源,然后把该进程放入进程就绪队列,进程调度器选中它的时候就会为它分配CPU时间,程序开始真正运行。线程线程是一条执行路径,是程序执行时的最小单位,它是进程的一... -
java_关于线程常用操作及同步锁
2018-09-02 08:08:52常用构造器: 常用方法: 线程调度: 守护线程: 其他堵塞的两个方法 同步锁: 等待阻塞 线程API: 常用构造器: Thread(Runnable r) 创建一个指定任务的线程对象 Thread(Runnable r, String name) ... -
java main是多线程的吗_Java多线程之线程及其常用方法
2021-02-28 06:05:02程序运行时系统就会创建一个进程,并为它分配资源,然后把该进程放入进程就绪队列,进程调度器选中它的时候就会为它分配CPU时间,程序开始真正运行。线程线程是一条执行路径,是程序执行时的最小单位,它是进程的一... -
SparkCore包括部署部署模块,执行执行器模块,内存存储模块,调度调度程序。模块,经典的Shuffle模块,存储...
2021-02-21 13:31:10目前列出来的是比较核心常用的框架源码,包括: 基础编程语言:Java、Scala 数据处理框架:Spark、Flink 欢迎小伙伴一起加入阅读,夯实自己的技术,体验其中的乐趣。 持续更新中... 原始阅读 一,spark core源码阅读... -
Java的Groovy执行器内存泄露问题分析与解决办法
2020-12-14 17:20:45GroovyClassLoader是一个Groovy定制的类装载器,负责解析加载Java类中用到的Groovy类,然而,目前该执行器会造成JDK本身的内存泄露。 现象: 由于我们的Java程序通过调度的方式来周期的方式进行运行,而程序中包含... -
java 6 多线程_java多线程(六)-线程的状态和常用的方法
2021-03-08 03:38:29一个线程可以处于以下几种状态之一:(1) ...(2)就绪(Runnable):万事俱备,只欠东风,该线程在等待着,只要调度器把时间片分配给线程,它就可以运行了。(3)阻塞(Blocked):线程虽然可以运行,但是缺乏某项资源,或... -
尚硅谷java(*):多线程1(程序/进程/线程+多线程的创建1:继承Thread类+测试thread的常用方法+线程的调度/...
2020-03-31 22:01:16程序/进程/线程概念 多线程的创建1:继承Thread类 //线程不能用t1.run()方法 多线程的交互性 ...第二种方式,创建匿名子类的方式 ...一个对象放到三个构造器中,三个线程用的同一个new window1(),自然t... -
JAVA多线程二:线程的六种状态及常用方法
2020-07-23 14:47:39一、线程的六种状态以及转化 二、线程中常用的方法 1、start() 方法 start() 方法用来启动一个线程,将其添加一个线程组当中,此时线程就会处于...yield()是一种启发式方法,线程A.yield(),会提醒调度器线程A愿意放 -
java多线程总结(二)之Thread类的常用方法
2019-06-07 11:33:27导致当前正在执行的县城休眠(暂时停止执行)指定的毫秒数,具体取决于系统计时器和调度程序的精度和准确性。 package com.thread; class MyRunnable implements Runnable{ @Override public void run() { ... -
java多线程——线程常用的一些方法解释以及线程同步
2019-07-25 09:28:01在阻塞的过程中,如果当前对象持有监视器对象上的锁,那么该锁不会被释放。 Join:导致当前线程进入阻塞状态,调用join 方法的线程对象优先被调度执行(相对于被阻塞的线程)。被阻塞的线程,当调用join 方法的线程... -
java多线程(六)-线程的状态和常用的方法
2017-03-19 18:10:00一个线程可以处于以下几种状态之一: (1) 新建(new):当...(2) 就绪(Runnable):万事俱备,只欠东风,该线程在等待着,只要调度器把时间片分配给线程,它就可以运行了。(3) 阻塞(Blocked):线... -
自动任务调度 - Timer
2019-11-14 13:29:59一、概述:小说搜索 biqi.org 最近维护一个老项目,里面使用的是Timer的时间调度器,以前没接触过,对着代码鼓捣了半天,查阅了部分博客,最后总结出自己的见解,新项目一般...二、常用的三种调度器分类 Java自带的... -
java多线程系列(二):Thread的常用方法讲解(sleep、wait、notify)
2018-12-05 02:05:54时间未必精准,具体取决于系统计时器和调度程序的精度和准确性。 run() run方法是线程的处理逻辑的方法 start() 启动线程的方法,java虚拟机会通过此方法调用run方法 notify() 调用某个对象的notify()方法能够唤醒一... -
Java线程池
2016-06-10 23:11:561、Java线程池实现了一个Java高并发的、Java多线程的、可管理的统一调度器。 2、Executors是个线程的工厂类,方便快速地创建很多线程池,也可以说是一个线程池的工具类。在该类里面提供了一些静态工厂,生成一些... -
technology-talk : 汇总 java 生态圈常用技术框架、开源中间件,系统架构、数据库、大公司架构案例、常用三方类库、项目管理、线上问题排查、个人成长、思考等知识 tutorials:该项目是一系列小而专注的教程 - 每个...
-
Java开发详解.zip
2019-09-02 17:46:13031116_【第11章:Java常用类库】_定时调度笔记.pdf 031201_【第12章:JAVA IO】_File类笔记.pdf 031202_【第12章:JAVA IO】_RandomAccessFile笔记.pdf 031203_【第12章:JAVA IO】_字节流与字符流笔记.pdf 031204_... -
java开源包1
2013-06-28 09:14:34MyBatchFramework 是一个开源的轻量级的用以创建可靠的易管理的批量作业的Java包,主要特点是多线程、调度、JMX管理和批量执行报表,执行历史等。 SIP协议包 jSIP.tar jSIP这个Java包目标是用Java实现SIP(SIP:... -
java开源包12
2013-06-28 10:14:45MyBatchFramework 是一个开源的轻量级的用以创建可靠的易管理的批量作业的Java包,主要特点是多线程、调度、JMX管理和批量执行报表,执行历史等。 SIP协议包 jSIP.tar jSIP这个Java包目标是用Java实现SIP(SIP:... -
Java 定时任务quartz实现方式
2020-04-30 11:28:44Java 定时任务quartz1. java自带 java.util.Timer 实现定时任务2. 使用线程池(ScheduledThreadPool-java.util.concurrent.... 使用Quartz定时任务调度器4.1 Quartz 特点4.2 核心概念4.3 常用对象4.... -
Java资源包01
2016-08-31 09:16:25MyBatchFramework 是一个开源的轻量级的用以创建可靠的易管理的批量作业的Java包,主要特点是多线程、调度、JMX管理和批量执行报表,执行历史等。 SIP协议包 jSIP.tar jSIP这个Java包目标是用Java实现SIP(SIP:... -
java开源包101
2016-07-13 10:11:08MyBatchFramework 是一个开源的轻量级的用以创建可靠的易管理的批量作业的Java包,主要特点是多线程、调度、JMX管理和批量执行报表,执行历史等。 SIP协议包 jSIP.tar jSIP这个Java包目标是用Java实现SIP(SIP:... -
java开源包11
2013-06-28 10:10:38MyBatchFramework 是一个开源的轻量级的用以创建可靠的易管理的批量作业的Java包,主要特点是多线程、调度、JMX管理和批量执行报表,执行历史等。 SIP协议包 jSIP.tar jSIP这个Java包目标是用Java实现SIP(SIP:... -
java开源包2
2013-06-28 09:17:39MyBatchFramework 是一个开源的轻量级的用以创建可靠的易管理的批量作业的Java包,主要特点是多线程、调度、JMX管理和批量执行报表,执行历史等。 SIP协议包 jSIP.tar jSIP这个Java包目标是用Java实现SIP(SIP:...