精华内容
下载资源
问答
  • 2018-05-02 16:48:43

    类中的三类方法

    类中的三类方法:普通、静态(static)、常方法(const)

    static:

    • 静态成员变量必须要在类外进行初始化;
    • 属于类但不属于对象,所以,计算类大小时,不算static成员变量大小;
    • 所有对象共用一个变量时使用static声明的变量;
    • static 成员方法没有this指针,直接用类的作用域调用;
    • static成员方法与变量在类外定义均不用加staic,但要加类作用域;
    • 普通成员方法可调用静态成员方法,static变量
    • static方法不能访问普通成员变量/方法(同一对象中的),只能访问其他static成员。

    const

    • 常方法可访问不可修改
    • const对象无法调用普通成员方法

      问题1:static和const能共存吗?
      不能,static是把this指针没了,而const是给this指针加const,这两者是矛盾的。
      问题2:常对象为什么不能调普通方法?
      默认情况下,this指针是指向非常量版本的常量指针。我们不能把this绑定到一个常量对象上(即int *const 绑定到 int const)这样也就使我们不能在一个常量对象上调用普通成员函数。

    mutable(突破const限制)

    主要用于后来扩充时,从前写的常方法增加需求。(不过尽量还是不要使用)
    三种方法使用注意:
    - 普通成员方法可调用静态成员方法,static变量
    - static方法不能访问普通成员变量/方法(同一对象中的),只能访问其他static成员。
    - const对象无法调用普通成员方法
    即普通方法都可调用(优先调普通),static只可调用同一对象static,const只可调const

    更多相关内容
  • 看到这个问题第一反应是不懂,然后查询了网上的一些说法,感觉略有不一。...然后,多个线程访问这个的两个方法也有不同的形式,例如访问这个的两个方法是通过同一个类的实例对象来访问还是通过不同...

    看到这个问题第一反应是不懂,然后查询了网上的一些说法,感觉略有不一。细看之下发现大家对这个问题的分析角度不太一样,就会出现不同的结果,在这里记一下我收集来的不同的角度和自己的例子,感觉这个题目还是蛮有意思的。

    首先,同步锁有两种,JVM的synchronized和JDK的ReentrantLock;
    然后,多个线程访问这个类的两个方法也有不同的形式,例如访问这个类的两个方法是通过同一个类的实例对象来访问还是通过不同的类的实例对象访问;
    再者,一个类的两个方法加了同步锁,这两个被同步方法也没有说明是什么样的方法。他可能是类的普通实例方法,也可能是类中Runnable对象的run方法。

    看到这里也许会觉得我对于问题过于的咬文嚼字,但是我想要探讨更多的可能,不同的情形有着不同的结果,而且这些不同的情形能开拓思路,让我们看问题能多个角度,也可以帮我加深多线程的理解。如果本文中有错误或者不恰当的例子,或者代码写的不严谨不规范风格不好,都可以留言提出。

    一.synchronized

    1.多个线程同时访问同一个类实例对象的两个同步方法:

    package synchronizedTest;
    
    public class Example1 {
    	private int num = 0 ;
    	(省略getter.setter,后同)
    	public synchronized void method1() {
    		System.out.println("同步方法1进入");
    		for(int i = 0 ; i<10 ; i++) {
    			System.out.print("同步方法1:"+num+"--");
    			num++ ;
    		}
    		System.out.println("同步方法1结束");
    	}
    	
    	public synchronized void method2() {
    		System.out.println("method2进入:");
    		for(int i = 0 ; i<10 ; i++) {
    			System.out.print("method2:"+num+"--");
    			num++ ;
    		}
    		System.out.println("method2结束");
    	}
    	
    	public static void main(String[] args) {
    		final Example1 example1 = new Example1() ;
    		
    		Thread thread1 = new Thread(new Runnable() {
    			@Override
    			public void run() {
    				example1.method1();
    			}
    		}) ;
    		
    		Thread thread2 = new Thread(new Runnable() {
    			@Override
    			public void run() {
    				example1.method2();
    			}
    		}) ;
    		try {
    			thread2.join();
    			thread1.join();			
    			thread1.start();
    			thread2.start();
    		} catch (InterruptedException e) {
    			// TODO Auto-generated catch block
    			e.printStackTrace();
    		}		
    	}
    	
    }
    

    输出结果:

    method1进入
    同步方法1:0--同步方法1:1--同步方法1:2--同步方法1:3--同步方法1:4--同步方法1:5--同步方法1:6--同步方法1:7--同步方法1:8--同步方法1:9--method1结束
    method2进入:
    method2:10--method2:11--method2:12--method2:13--method2:14--method2:15--method2:16--method2:17--method2:18--method2:19--method2结束
    

    显然此时多个线程是不能访问同个类(的一个实例对象)的两个同步方法的

    2.多个线程同时访问同一个类的不同实例对象的两个同步方法:
    将上面的代码稍作修改,主函数中多new一个该类实例

    final Example1 example2 = new Example1() ;
    

    再修改thread2的run方法调用的类实例为example2

    Thread thread2 = new Thread(new Runnable() {
    			@Override
    			public void run() {
    				example2.method2();
    			}
    		}) ;
    

    得到结果:

    同步方法1进入
    method2进入:
    method2:0--method2:1--同步方法1:0--同步方法1:1--同步方法1:2--method2:2--同步方法1:3--method2:3--同步方法1:4--method2:4--同步方法1:5--method2:5--同步方法1:6--同步方法1:7--method2:6--同步方法1:8--同步方法1:9--method2:7--同步方法1结束
    method2:8--method2:9--method2结束
    

    这时候显然,多个线程是能访问同个类(的不同实例对象)的两个同步方法的。

    小结:这是因为synchronized是对象锁,即线程获得的锁是施加在一个实例对象上的,如果不同的线程访问的是同一对象上的不同的同步方法,那么显然不能同时进行。
    如果是不同对象上的不同的同步方法,那么就是可以同时进行的。

    3.多个线程同时访问同一个类实例对象的两个Runnable对象的run方法:

    package synchronizedTest;
    
    public class Example2 {
    	private int num ;
    	public Runnable runnable1 = new Runnable() {
    		@Override
    		public void run() {
    			//同步锁
    			synchronized (this) {
    				System.out.println("线程1进入");
    				for(int i = 0 ; i < 10 ; i ++) {
    					System.out.print("线程1:"+num+"--");
    				}
    				System.out.println("线程1结束");
    			}
    		}
    	};
    	
    	public Runnable runnable2 = new Runnable() {
    		@Override
    		public void run() {
    			//同步锁
    			synchronized (this) {
    				System.out.println("thread2进入");
    				for(int i = 0 ; i < 10 ; i ++) {
    					System.out.print("thread2:"+num+"--");
    				}
    				System.out.println("thread2结束");
    			}
    		}
    	};
    	
    	public static void main(String[] args) {
    		Example2 example = new Example2() ; //创建一个对象
    		new Thread(example.runnable1).start(); //同步方法1
    		new Thread(example.runnable2).start(); //同步方法2
    	}
    }
    
    

    输出结果:

    thread2进入
    线程1进入
    thread2:0--线程1:0--线程1:0--thread2:0--线程1:0--线程1:0--线程1:0--thread2:0--线程1:0--thread2:0--thread2:0--线程1:0--thread2:0--线程1:0--thread2:0--thread2:0--线程1:0--thread2:0--线程1:0--thread2:0--线程1结束
    thread2结束
    

    可见此时多个线程是能同时访问同个类的两个同步方法的。这是因为
    synchronized(this){ //... }中锁住的不是代码块,即这个锁在run方法中,但是并不是同步了这个run方法,而是括号中的对象this,也就是说,多个线程会拿到各自的锁,就能够同时执行run方法。(在run方法前声明synchronized也是同样的效果)

    new Thread(example.runnable1).start(); //同步方法1
    new Thread(example.runnable2).start(); //同步方法2
    

    打印出这个this对象,是两个不同的类实例对象:

    synchronizedTest.Example2$1@65db6dfa
    synchronizedTest.Example2$2@471fab
    

    也说明了不同线程的实例对象不同,都是各自对象的锁,不可以认为是类似于例子1中的同一实例对象,而应该类似与例子2的不同类的实例对象

    总结:分析synchronized同步锁的核心在于他是个对象锁,找清楚锁的对象

    二.ReentrantLock锁
    1.多个线程同时访问同一个类实例对象的两个同步方法:
    将例子1的synchronized改为引入ReentrantLock

    package ReentrantLockTest;
    
    import java.util.concurrent.locks.Lock;
    import java.util.concurrent.locks.ReentrantLock;
    
    public class LockExample {
    	private int num;
    	private Lock lock = new ReentrantLock();
    
    	public void method1() {
    			lock.lock();
    			System.out.println("同步方法1进入");
    			for(int i = 0 ; i<10 ; i++) {
    				System.out.print("同步方法1:"+num+"--");
    				num++ ;
    			}
    			System.out.println("同步方法1结束");
    			lock.unlock();
    	}
    
    	public void method2() {
    		lock.lock();
    		System.out.println("method2进入:");
    		for (int i = 0; i < 10; i++) {
    			System.out.print("method2:" + num + "--");
    			num++;
    		}
    		System.out.println("method2结束");
    		lock.unlock();
    	}
    
    	public static void main(String[] args) {
    		final LockExample example = new LockExample() ;
    		Thread thread1 = new Thread(new Runnable() {
    			@Override
    			public void run() {
    				example.method1();
    			}
    		}) ;
    		
    		Thread thread2 = new Thread(new Runnable() {
    			@Override
    			public void run() {
    				example.method2();
    			}
    		}) ;
    		
    		try {
    			thread2.join();
    			thread1.join();
    			thread1.start();
    			thread2.start();
    		} catch (InterruptedException e) {
    			e.printStackTrace();
    		}
    	}
    }
    
    

    输出结果:

    同步方法1进入
    同步方法1:0--同步方法1:1--同步方法1:2--同步方法1:3--同步方法1:4--同步方法1:5--同步方法1:6--同步方法1:7--同步方法1:8--同步方法1:9--同步方法1结束
    method2进入:
    method2:10--method2:11--method2:12--method2:13--method2:14--method2:15--method2:16--method2:17--method2:18--method2:19--method2结束
    

    可见此时多个线程是不能访问同个类(的一个实例对象)的两个同步方法的

    2.多个线程同时访问同一个类的不同实例对象的两个同步方法:
    修改main函数的即可:

    public static void main(String[] args) {
    		final LockExample example1 = new LockExample() ;//两个实例
    		final LockExample example2 = new LockExample() ;
    		Thread thread1 = new Thread(new Runnable() {
    			@Override
    			public void run() {
    				example1.method1(); //实例1的同步方法1
    			}
    		}) ;
    		
    		Thread thread2 = new Thread(new Runnable() {
    			@Override
    			public void run() {
    				example2.method2();//实例2的同步方法2
    			}
    		}) ;
    		
    		try {
    			thread2.join();
    			thread1.join();
    			thread1.start();
    			thread2.start();
    		} catch (InterruptedException e) {
    			e.printStackTrace();
    		}
    	}
    

    输出结果:

    同步方法1进入
    method2进入:
    同步方法1:0--method2:0--method2:1--同步方法1:1--method2:2--同步方法1:2--同步方法1:3--method2:3--同步方法1:4--method2:4--同步方法1:5--同步方法1:6--method2:5--同步方法1:7--method2:6--同步方法1:8--同步方法1:9--同步方法1结束
    method2:7--method2:8--method2:9--method2结束
    
    

    可见,多个线程是能访问同个类(的不同实例对象)的两个同步方法的。

    总结:ReentrantLock和synchronized的前两个例子结论都相同

    3.多个线程同时访问同一个类实例对象的两个Runnable对象的run方法:

    package ReentrantLockTest;
    
    import java.util.concurrent.locks.Lock;
    import java.util.concurrent.locks.ReentrantLock;
    
    public class Lockexample2 {
    
    	private int num;
    	private Lock lock = new ReentrantLock();
    	
    	public Runnable runnable1 = new Runnable() {
    		@Override
    		public void run() {
    			lock.lock();//上锁
    			System.out.println("线程1进入");
    			for(int i = 0 ; i < 10 ; i ++) {
    				System.out.print("线程1:"+num+"--");				
    			}
    			System.out.println("线程1结束");
    			lock.unlock();
    		}
    	};
    	
    	public Runnable runnable2 = new Runnable() {
    		@Override
    		public void run() {
    			lock.lock();//上锁
    			System.out.println("thread2进入");
    			for(int i = 0 ; i < 10 ; i ++) {
    				System.out.print("thread2:"+num+"--");
    			}
    			System.out.println("thread2结束");
    			lock.unlock();
    		}
    	};
    	
    	public static void main(String[] args) {
    		Lockexample2 example = new Lockexample2();
    		new Thread(example.runnable1).start(); 
    		new Thread(example.runnable2).start(); 
    		
    	}
    }
    
    

    输出结果:

    线程1进入
    线程1:0--线程1:0--线程1:0--线程1:0--线程1:0--线程1:0--线程1:0--线程1:0--线程1:0--线程1:0--线程1结束
    thread2进入
    thread2:0--thread2:0--thread2:0--thread2:0--thread2:0--thread2:0--thread2:0--thread2:0--thread2:0--thread2:0--thread2结束
    
    

    这里可以看到,与synchronized的第三个例子出现了不同的结果。在这个地方,ReentrantLock不允许多线程同时访问一个类的不同同步方法。
    这里要注意的是ReentrantLock与synchronized不同,ReentrantLock的实现方式是要先创建ReentrantLock对象,然后用这个对象的方法来上锁。而一个类的实例中只有一个ReentrantLock对象:

    private Lock lock = new ReentrantLock();
    

    而本例中,线程的创建是建立在同一个类实例上的:

    Lockexample2 example = new Lockexample2();
    new Thread(example.runnable1).start(); 
    new Thread(example.runnable2).start(); 
    

    因此,ReentrantLock对象lock是同一个,因此第一个线程进入同步方法1后就获取了锁,第二个线程无法获取这个锁,只能等待。

    如果换成是两个实例对象:

    public static void main(String[] args) {
    		Lockexample2 example = new Lockexample2();
    		Lockexample2 example2 = new Lockexample2();
    		new Thread(example.runnable1).start(); 
    		new Thread(example2.runnable2).start(); 
    		
    	}
    

    输出结果

    线程1进入
    thread2进入
    线程1:0--线程1:0--线程1:0--线程1:0--thread2:0--线程1:0--thread2:0--thread2:0--thread2:0--thread2:0--thread2:0--thread2:0--thread2:0--线程1:0--thread2:0--线程1:0--线程1:0--thread2:0--线程1:0--thread2结束
    线程1:0--线程1结束
    
    

    可见不同的实例对象中是不同的ReentrantLock对象,因此可以同时访问

    小结:ReentrantLock锁的核心在与ReentrantLock对象是不是同一个

    三.结论
    重新看看这个问题:一个类中的两个方法都加了同步锁,多个线程能同时访问这个类的两个方法吗?

    现在应该比较清楚了,这个问题要分成synchronized和ReentrantLock两个情况:

    一.对于synchronized
    1.一个类中的两个方法都加了同步锁,多个线程不能同时访问这个类的同一实例对象的两个方法
    2.一个类中的两个方法都加了同步锁,多个线程同时访问这个类的不同实例对象的两个方法
    3.一个类中的两个方法**(Runnable的run方法)都加了同步锁,多个线程能**同时访问这个类的两个方法(不论是不是同一实例对象)

    二.对于ReentrantLock
    1.一个类中的两个方法都加了同步锁,多个线程不能同时访问这个类的同一实例对象的两个方法(不论同步加在实例方法中或是run方法中)
    2.一个类中的两个方法都加了同步锁,多个线程同时访问这个类的不同实例对象的两个方法(不论同步加在实例方法中或是run方法中)

    展开全文
  • java开启新线程的三种方法方法1:继承Thread 1):定义bai一个继承自Java.lang.Thread的duA. 2):覆盖zhiAThread类中的run方法。 3):我们编写需要run方法中执行的操作:run方法中的代码,线程...

    java开启新线程的三种方法:

    方法1:继承Thread类

    1):定义bai一个继承自Java.lang.Thread类的du类A.

    2):覆盖zhiA类Thread类中的run方法。

    3):我们编写需要在run方法中执行的操作:run方法中的代码,线程执行体。

    4):在main方法(线程)中,创建一个线程对象并启动线程。

    (1)创建线程类对象:                

    A类   a  =  new   A类();

    (2)调用线程对象的start方法:    

    a.start();//启动一个线程

    注意:不要调用run方法。如果run方法被称为对象调用方法,则仍然只有一个线程,并且没有启动新线程。

    创建启动线程实例:

    //定义一个类A 继承java.lang.Thread
    class A extends Thread{
        //A类 覆盖Thread类中的 run方法
        @Override
        public void run(){
            //在run方法填写要执行的操作
            for (int j = 0 ;j<10;j++){
                System.out.println("执行方法A的逻辑"+j);
            }
         }
    }
    
    public Class B{
        public static void main(String[] args){
            for (int i = 0;i<50 ;i++){
                System.out.println(i);
                if(i==10){
                    // 在线程中重开一个线程执行其他操作
                    A a = new A();
                    a.start();
                }
                try {
                    if (i==10){
                        Thread.sleep(1000);
                    }
                }catch (InterruptedException e){
                    e.printStackTrace();
                }
            }
        }
    }
    方法2:实现Runnable接口
    
    1):定义要在java.lang.Runnable接口中实现的类A.请注意,A类不是线程类。
    
    2):覆盖A类Runnable接口中的run方法。
    
    3):我们编写需要在run方法中执行的操作:在run方法中,线程执行。
    
    4):在main方法(线程)中,创建一个线程对象并启动线程。
    
    (1)创建线程类对象:
    
    Thread  t = new Thread(new  A());    
    
    (2)调用线程对象的start方法:
    
    t.start();
    

    代码实例:

    //定义一个类C 实现java.lang.Runnable 接口 C类不是线程类
    class C implements Runnable{
        //C类 覆盖Runnable接口中的 run方法
        @Override
        public void run(){
            //在run方法填写要执行的操作
            for (int j = 0 ;j<10;j++){
                System.out.println("执行方法C的逻辑"+j);
            }
        }
    }
    
    public Class B{
    
        public static void main(String[] args){
            for (int i = 0;i<100 ;i++){
                System.out.println(i);
                if(i==10){
                    // 在线程中重开一个线程执行其他操作
                    C c = new C();
                    Thread t = new Thread(c);
                    t.start();
                }
                try {
                    if (i==10){
                        System.out.println(Thread.currentThread().getName());
                        Thread.sleep(1000);
                    }
                }catch (InterruptedException e){
                    e.printStackTrace();
                }
            }
        }
    }

    方法3:直接在函数体使用

        public static void main(String[] args){
    
            for (int i=0;i<20;i++){
                System.out.println(i);
                if(i==10){
    
                    Thread thread = new Thread(new Runnable() {
                        @Override
                        public void run() {
                            for(int j=0;j<10;j++){
                                System.out.println("j"+j);
                            }
                        }
                    });
                    thread.start();
    
                    try {
                        if (i==10){
                            System.out.println(Thread.currentThread().getName());
                            Thread.sleep(1000);
                        }
                    }catch (InterruptedException e){
                        e.printStackTrace();
                    }
                }
            }
    
        }

    弊端:

    1、每次都要new thread,新建了一个对象,导致对象性能差。

    2、线程缺乏统一管理,可能无限制新建线程,相互之间出现竞争,极可能占用过多系统资源导致死机或者oom。

    3、缺乏更多功能,比如:定时定时执行,定期执行,线程中断。

    相比new Thread而言,Java提供的四种线程池的好处在于:

       ①可复用存在的线程,减少对象的创建、消亡,性能较高。

       ②有效控制并发线程数,提高了系统资源的使用率,避免了过多争夺系统资源,导致的堵塞。

       ③提供了定时执行、定期执行、单线程、并发数控制等功能。

    Java通过Executors提供了四种线程池

    •       newCachedThreadPool 创建一个可缓存线程池,如果线程池长度超过处理需要,可灵活回收空闲线程,若无可回收,则新建线程。线程池的规模不存在限制。
    •       newFixedThreadPool 创建一个固定长度线程池,可控制线程最大并发数,超出的线程会在队列中等待。
    •       newScheduledThreadPool 创建一个固定长度线程池,支持定时及周期性任务执行。
    •       newSingleThreadPool 创建一个单线程化的线程池,它只会用唯一的工作线程来执行任务,保证所有任务按照指定顺序(FIFO, LIFO, 优先级)执行。

     newCachedThreadPool:

    创建一个可缓存的线程池,如果线程池长度超过处理需要,可灵活回收空闲线程,如无回收,则新建线程

    ExecutorService cachedThreadPool = Executors.newCachedThreadPool();
      for(int i=0; i<10;i++){
         final int index=i;
          try{
                 Thread.sleep(index*1000);
              }catch(InterruptedException e){
                    e.printStackTrace();
              }
               cachedThreadPool.execute(new Runnable(){
                      @override
                          public  void  run(){
                                 System.out.println(index);
                        }
                });
       }        

    newFixedThreadPool:

    创建一个定长线程池,可控制线程最大并发数,超出的线程会在队列中等待,定长线程池的大小最好根据系统资源进行设置。

    ExecutorService fixedThreadPool = Executors.newFixedThreadPool(3);
    for (int i = 0; i < 10; i++) {
        final int index = i;
        fixedThreadPool.execute(new Runnable() {
    
            @Override
            public void run() {
                try {
                    System.out.println(index);
                    Thread.sleep(2000);
                } catch (InterruptedException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
            }
        });
    }

    newScheduledThreadPool:

    创建一个定长线程池,支持定时及周期性任务执行,ScheduledExecutorService比Timer更安全,功能更强大。

    ScheduledExecutorService scheduledThreadPool = Executors.newScheduledThreadPool(5);
    scheduledThreadPool.schedule(new Runnable() {
    
        @Override
        public void run() {
            System.out.println("delay 3 seconds");
        }
    }, 3, TimeUnit.SECONDS);
    此表示为延迟3秒执行
    scheduledThreadPool.scheduleAtFixedRate(new Runnable() {
    
        @Override
        public void run() {
            System.out.println("delay 1 seconds, and excute every 3 seconds");
        }
    }, 1, 3, TimeUnit.SECONDS);
    此表示为延迟1秒后每3秒执行一次

    newSingleThreadPool:

    创建一个单线程化的线程池,它只会用唯一的工作线程来执行任务,保证所有任务按照指定顺序执行

    ExecutorService singleThreadExecutor = Executors.newSingleThreadExecutor();
    for (int i = 0; i < 10; i++) {
        final int index = i;
        singleThreadExecutor.execute(new Runnable() {
    
            @Override
            public void run() {
                try {
                    System.out.println(index);
                    Thread.sleep(2000);
                } catch (InterruptedException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
            }
        });
    }

     

    newCachedThreadPool 特点:

    1.核心线程数为零    2.最大线程数为无限  3.无任务时,线程存活的最大时间为60s  4.任务队列为同步移交队列,该队列没有缓冲区,即不会有任务会在该队列中排队,每当有任务要入队时,队列都会将任务移交给一个可用的线程

    为什么叫缓存线程池,类比于redis缓存:

    前者缓存的是频繁要用到的线程;后者缓存的是频繁要用到的数据

    前者通过缓存线程,避免了每次执行任务都要创建、销毁线程的开销;后者通过缓存数据,避免了每次用到数据都要操作db

    两者都有缓存失效的时间,前者对应keepAliveTime参数,超过该参数对应的时间后,销毁线程;后者当缓存对应的真实数据被修改时,缓存失效,清除数据

    为了尽量重复利用缓存的线程,而不是每次要执行任务时创建新的线程,应尽量使执行任务的时间小于keepAliveTime参数,默认是60s

    因为是一个“缓存”线程池,没有缓存可以永久有效,因此核心线程数为0。因此任务队列的缓冲区应为空,否则即便系统有可用的线程资源,当有新的任务时也不会被执行,而是进入任务队列排队直至队列满,这显然是不合理的。同样由于队列缓冲区为空,每来一个任务时,都会在必要时新建线程执行任务,这就有可能导致大量的线程被创建,进而系统瘫痪。

     

    1 newCachedThreadPool创建一个可缓存线程池,如果线程池长度超过处理需要,可灵活回收空闲线程,若无可回收,则新建线程。Executors.newCachedThreadPool(); 缺点:大家一般不用是因为newCachedThreadPool 可以无线的新建线程,容易造成堆外内存溢出,因为它的最大值是在初始化的时候设置为 Integer.MAX_VALUE,一般来说机器都没那么大内存给它不断使用。当然知道可能出问题的点,就可以去重写一个方法限制一下这个最大值
    2 newFixedThreadPool  Executors.newFixedThreadPool(3);创建一个定长线程池,可控制线程最大并发数,超出的线程会在队列中等待。定长线程池的大小最好根据系统资源进行设置。如Runtime.getRuntime().availableProcessors()。可参考PreloadDataCache。其实newFixedThreadPool()在严格上说并不会复用线程,每运行一个Runnable都会通过ThreadFactory创建一个线程
    3 newScheduledThreadPool 创建一个定长线程池,支持定时及周期性任务执行。Executors.newScheduledThreadPool(5);与Timer 对比:Timer 的优点在于简单易用,但由于所有任务都是由同一个线程来调度,因此所有任务都是串行执行的,同一时间只能有一个任务在执行,前一个任务的延迟或异常都将会影响到之后的任务(比如:一个任务出错,以后的任务都无法继续)。
    ScheduledThreadPoolExecutor的设计思想是,每一个被调度的任务都会由线程池中一个线程去执行,因此任务是并发执行的,相互之间不会受到干扰。需要注意的是,只有当任务的执行时间到来时,ScheduedExecutor 才会真正启动一个线程,其余时间 ScheduledExecutor 都是在轮询任务的状态。
    通过对比可以发现ScheduledExecutorService比Timer更安全,功能更强大,在以后的开发中尽可能使用ScheduledExecutorService(JDK1.5以后)替代Timer
    4 newSingleThreadExecutor Executors.newSingleThreadExecutor() 创建一个单线程化的线程池,它只会用唯一的工作线程来执行任务,保证所有任务按照指定顺序(FIFO, LIFO, 优先级)执行。现行大多数GUI程序都是单线程的。Android中单线程可用于数据库操作,文件操作,应用批量安装,应用批量删除等不适合并发但可能IO阻塞性及影响UI线程响应的操作。

     

    下面举一个newFixedThreadPool 应用示例:

     

    import AThreadService;
    
    //调用自己写好的异步处理逻辑的方法
    public A {
        @Autowired
      	private AThreadService AThreadService;
        public static void main (String [] args){
            AThreadService.AThread((String)A,(Object)B, (String)C);
        }
    }
    
    
    // 接口
    public interface AThreadService {
    	/**
    	 * 方法名称: AThread
    	 * @throws
    	 */
    	public void  AThread(String A, Object B, String C);
    	
    }
    
    //实现类
    public class AThreadSpringImpl  implements AThreadService{
    
    	@Autowired
    	private AService AService;
    	
        //线程根据实际情况设置大小
    	private static final ExecutorService AThreadPool = Executors.newFixedThreadPool(10);
    
    	public void AThread(String A, Object B,String C) {
    		// TODO Auto-generated method stub
    		AThread aThread = new AThread(A,B,C);
    		AThread.setAService(AService);
    		AThreadPool.execute(AThread);
    	}
    	
    }
    
    //线程类实现runable接口
    public class AThread implements Runnable {
    	
    	private Log log = LogFactory.getLog(AThread.class);
    	
    	private static final long serialVersionUID = 1L;
    
    	private String A;
    	private Object B;
    	private String C;
    	private AService AService;
    	
    	public AService AService() {
    		return aService;
    	}
    
    	public void setAService(AService aService) {
    		this.aService = aService;
    	}
    
        public  AThread(String A, Object B, String C)
        {
         this.A=A;
         this.B=B;
         this.C=C;
        }
        
        public void run() {
    		// TODO Auto-generated method stub
        	log.info("-----------开始----------");
        	
    		aService.afunction(A, B, C);
    		
    		log.info("-----------结束----------");
    	}
    
    }
    
    // 实现类实现方法
    public class AServiceSpringImpl implements AService {
    	 
    	/** 
    	 *  
    	 * 方法名称: afunction 
    	 * @throws 
    	 */ 
    	public void afunction(String A,Object B,String C){ 
             
            //Do something;
            System.out.println("业务逻辑");
    	} 
    } 

        在《阿里巴巴java开发手册》中指出了线程资源必须通过线程池提供,不允许在应用中自行显示的创建线程,这样一方面是线程的创建更加规范,可以合理控制开辟线程的数量;另一方面线程的细节管理交给线程池处理,优化了资源的开销。而线程池不允许使用Executors去创建,而要通过ThreadPoolExecutor方式,这一方面是由于jdk中Executor框架虽然提供了如newFixedThreadPool()、newSingleThreadExecutor()、newCachedThreadPool()等创建线程池的方法,但都有其局限性,不够灵活;另外由于前面几种方法内部也是通过ThreadPoolExecutor方式实现,使用ThreadPoolExecutor有助于大家明确线程池的运行规则,创建符合自己的业务场景需要的线程池,避免资源耗尽的风险。

        详细内容参考:https://www.cnblogs.com/dafanjoy/p/9729358.html

        线程池不允许使用Executors去创建,而是通过ThreadPoolExecutor的方式,这样的处理方式让写的同学更加明确线程池的运行规则,规避资源耗尽的风险。 说明:Executors返回的线程池对象的弊端如下:
    1)FixedThreadPool和SingleThreadPool:
      允许的请求队列长度为Integer.MAX_VALUE,可能会堆积大量的请求,从而导致OOM。
    2)CachedThreadPool:
      允许的创建线程数量为Integer.MAX_VALUE,可能会创建大量的线程,从而导致OOM。
                
    Positive example 1:
        //org.apache.commons.lang3.concurrent.BasicThreadFactory
        ScheduledExecutorService executorService = new ScheduledThreadPoolExecutor(1,
            new BasicThreadFactory.Builder().namingPattern("example-schedule-pool-%d").daemon(true).build());
           
            
                
    Positive example 2:
        ThreadFactory namedThreadFactory = new ThreadFactoryBuilder()
            .setNameFormat("demo-pool-%d").build();

        //Common Thread Pool
        ExecutorService pool = new ThreadPoolExecutor(5, 200,
            0L, TimeUnit.MILLISECONDS,
            new LinkedBlockingQueue<Runnable>(1024), namedThreadFactory, new ThreadPoolExecutor.AbortPolicy());

        pool.execute(()-> System.out.println(Thread.currentThread().getName()));
        pool.shutdown();//gracefully shutdown
           
            
                
    Positive example 3:
        <bean id="userThreadPool"
            class="org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor">
            <property name="corePoolSize" value="10" />
            <property name="maxPoolSize" value="100" />
            <property name="queueCapacity" value="2000" />

        <property name="threadFactory" value= threadFactory />
            <property name="rejectedExecutionHandler">
                <ref local="rejectedExecutionHandler" />
            </property>
        </bean>
        //in code
        userThreadPool.execute(thread);

    展开全文
  • 有不少用户电脑系统发现弹出一个警告窗口,提示“没有注册类别”或“没有注册”的提示,但出现这样的问题又有些不同,因为有的是不同情况下发生的,所以我们必须根据具体情况作出正确的解决步骤。...

    有不少用户在电脑系统中发现弹出一个警告窗口,提示“没有注册类别”或“没有注册类”的提示,但出现这样的问题又有些不同,因为有的是在不同情况下发生的,所以我们必须根据具体情况作出正确的解决步骤。通常是动态链文件出错引起,下面提供几种解决方法。

    方法一:

    1、如果在运行service.exe打开服务列表时提示“没有注册类别”;

    0b211020c898fa9b8d6a62573e737882.png

    2、那么按Win+R打开运行,输入并执行命令:regsvr32 %windir%\system32\mmcndmgr.dll;

    c21dba28f3edad853d132562a5e6f8e3.png

    3、注册成功会有提示,点击确定,不然就到相同的系统中拷贝,保存到C:\Windows\System32,再进行注册即可。

    0a1a8da4e4dd1192833f706025293f5c.png

    方法二:

    1、使用Chrome(谷歌)浏览器的用户也会遇到“没有注册类”的错误提示;

    a820ed16a7f51e06e93c42f1ee7ce61f.png

    2、在运行中输入regedit并回车打开注册表编辑器;

    d1cb237d4c94a21ebe5bacdb71d3833b.png

    3、搜索Chrome,找到相关的两个项并删除即可。

    58a224ea9f35404222f19572de2260a6.png

    方法三:

    1、如果不知道是什么动态链文件出问题,可以运行cmd,打开命令提示符;

    e6332c0ff78e59c9f32758da38a3fb86.png

    2、分别执行以下命令:

    for %1 in (%windir%\system32\*.dll) do regsvr32.exe /s %1

    edf3009425e3a4e59b379551fcfd046e.png

    3、重新打开cmd,执行以下命令:

    for %1 in (%windir%\system32\*.ocx) do regsvr32.exe /s %1

    c375ea292828bca46cf39b6e8193ec22.png

    4、等待完成,并重启电脑。

    方法四:

    1、如果是在安装软件的过程中出现“没有注册类别”提示,一般由于程序与系统不兼容引起的;

    3d5e081fd069f53be4c7819c32bbea18.png

    2、右击安装程序打开属性,在“兼容性”中,勾选“以兼容模式运行这个程序”,并选择可兼容的操作系统,点击确定,并重新运行安装程序。

    61f41a3dc5202df787712a08ed0d11ae.png

    但电脑出现“没有注册类别”的错误提示时,有可能是多种原因引起的,所以我们要根据具体的情况,参考本教程中的方法来解决这个问题。

    展开全文
  • 简介 上一篇文章《Javasynchronized实现对象锁的两方式及原理解析》,介绍了方法锁的两实现方式及Synchronized的底层原理,本文将讲解synchronized的锁的两实现方式。...此时,就出现了同一个类中多个对
  • 3个只出现一次的数字,他们的bit位肯定不可能全部相同,也就是说,虽然有些bit位上的数可能相等,但肯定至少存在某一个bit位,这个数,有两个数的该bit位为1,一个数的该bit位为0,或者两个数的该bit位
  • 假设检验的两错误

    千次阅读 2019-05-12 21:37:13
    假设检验的两错误 假设检验及其两错误是数理统计学的名词...假设检验的两错误是指假设检验,由于样本信息的局限性,势必会产生错误,错误无非只有两情况,统计学,我们一般称为Ⅰ错误,Ⅱ...
  • 基于SVM的中文文本分类方法

    千次阅读 2017-06-15 16:50:21
    基于SVM的中文文本分类方法 1、文本分类简介 文本分类(Text Classification)是将文本文档与规定好的类别进行匹配的过程。文本分类可以分为训练和分类两阶段,其对应的流程图如下面的图1.1和图1.2所示: 图...
  • 主要有三类不同的学习方法:监督学习(Supervised learning)、非监督学习(Unsupervised learning)、半监督学习(Semi-supervised learning)。 监督学习:通过已有的一部分输入数据与输出数据之间的相应关系。生成一个...
  • 分类是一重要的数据挖掘技术,其目的是根据数据集的特点构造一个分类函数或分类模型(也常称作分类器),该模型能把未知类别的样本映射到给定的类别当中。 分类可描述如下:输入数据,或称训练集(TrainingSet)...
  • python:基础

    万次阅读 多人点赞 2018-06-17 01:14:53
    oop把对象作为程序的基本单元,一个对象包含数据和操作数据的函数2、python,所有数据类型都被视为对象,也可以自定义对象。自定义对象数据类型就是面向对象中类的概念1、(Class): 用来描述具有相同的属性和...
  • 一种是其它的加载器,是Java实现的,独立于JVM,全部都继承自抽象java.lang.ClassLoader。jdk自带了种类加载器,分别是启动加载器(Bootstrap ClassLoader),扩展加载器(Extension ClassLoa...
  •   安装某些软件,我们正准备开开心心地打开,哦豁,duang的一声弹出一个框框。就像下面这样 这时候是不是一筹莫展呢?别灰心,这问题大多数还是能解决的。 1. DLL文件的概念 1.1 什么是dll文件   DLL...
  • 聊使用事务时(@Transactional)可能出现的问题

    千次阅读 多人点赞 2020-08-20 08:11:31
    介绍了使用Spring事务中可能碰到的各种问题。例如事务失效、事务回滚异常、读写分离下事务如何处理等
  • 网络层—IP地址的三种分类方式

    万次阅读 2015-12-01 17:09:57
    IP地址是给因特网上的每一个主机或者是路由器的每一个接口(注意是接口,而不是主机或者是路由器本身)分配的一个在全世界范围唯一的32位的标识符。IP地址是由ICANN(Internet Corporation for Assigned Names and...
  • 分类解决类别不平衡问题

    万次阅读 多人点赞 2018-05-11 22:19:31
    关注微信公众号【Microstrong】,我现在研究方向是机器学习、深度学习,分享我学习过程的读书笔记!起来学习,起来交流,起来进步吧!本文同步更新我的微信公众号里面,公众号文章地址:...
  • Python中类的多继承

    千次阅读 2019-05-21 18:02:49
    文章目录Python中类的多继承多继承Python多继承实现多继承的缺点Mixin*思路1**思路2**思路3**思路4*Mixin Python中类的多继承 Python2.2之前是没有共同的祖先的,之后,引入object,它是所有的共同祖先...
  • 问题: 有时候用selenium操作浏览器,打开多页面后,不用的时候,需要关掉,切换页面需要切换句柄,关掉页面后,也需要重新切换句柄,否则页面接着操作元素会出问题 解决方法
  • Java和对象 详解(

    万次阅读 多人点赞 2016-10-06 20:48:02
    、面向对象简述面向对象是一种现在最为流行的程序设计方法,几乎现在的所有应用都以面向对象为主了,最早的面向对象的概念实际上是由IBM提出的,70年代的Smaltalk语言之进行了应用,后来根据面向对象的设计...
  • 具体信息答:GISshapfile文件的属性表连接Excel表时显示“连接数据库失败“的两解决方法: 把excel保存为03版本的。别存成10.或者07版本的。 EXCEL的单元格格式设置一下; 把时间段 的单元格设置成yyyy/mm/dd hh...
  • 测试方法-等价划分

    万次阅读 多人点赞 2020-04-06 23:36:39
    测试方法测试方法1、黑盒-等价例1:测试一个两位数的加法计算器例2:余额宝提现例3:三角形测试用例设计 测试方法 软件测试方法 经典定义: 软件测试(Software Testing),规定的条件下对程序进行操作,以发现程序...
  • SVM的实现多分类的几种方法以及优缺点详解

    万次阅读 多人点赞 2018-08-22 16:17:50
    转载自: ... ... SVM本身是一个二值分类器  SVM算法最初是为二值分类问题设计的,当处理多问题时,就需要构造合适的多分类器。  目前,构造SVM多分类器的方法主要有两 ...
  • 的继承(三种继承方式)

    万次阅读 2018-07-05 22:30:35
    时候,派生继承了基类的公有部分和保护部分,并且继承的这一些数据成员以私有部分存在于派生类中。基类的私有继承无法访问。2,派生保护继承于基类。这时候,派生继承了基类的公有部分和保护部分,并且...
  • 深入理解Java加载器():Java加载原理解析

    万次阅读 多人点赞 2017-05-15 20:47:44
    开发人员对java.lang...本文简述了JVM三种预定义加载器,即启动加载器、扩展加载器和系统加载器,并介绍和分析它们之间的关系和加载所采用的双亲委派机制,给出并分析了与Java加载原理相关的若干问题。
  • 怎么海量数据找出重复次数最多的一个

    万次阅读 多人点赞 2017-02-22 11:32:26
    1、海量日志数据,提取出某日访问百度次数最多的... 再详细介绍下此方案:首先是这一天,并且是访问百度的日志的IP取出来,逐个写入到一个大文件。注意到IP是32位的,最多有个2^32个 IP。同样可以采用映射的方法
  • 1.基于概率统计的Bayes分类器 因为实际分类由于考虑的侧重点不同或者关心的点不一样导致不能使用同一决策去解决所有的事件的分类,所以需要根据不同的准测函数选择不同的分类决策(基于最小错误率的Bayes决策,...
  • 在一个类中可能出现三种方法,实例方法、静态方法类方法,下面来看看三种方法的不同: 1、实例方法 实例方法的第一个参数必须是”self”,实例方法只能通过实例进行调用,这时候“self”就代表这个实例...
  • 之间的几关系

    千次阅读 2020-07-21 14:33:09
    一、继承关系 继承指的是一个类(称为子类、子接口)继承另外的一个类(称为父类、父接口)的功能,并可以增加它自己的新功能的能力。Java中继承关系通过关键字extends明确标识,设计时一般没有争议性。UML...
  • 带你了解软件工程的关系、UML图1.UML图简介2.UML图分类3.类图二、六大关系1.依赖关系(Dependence)2.泛化关系(Generalization)3.实现关系(Realization)4.关联(Association)5.聚合(Aggregation)...
  • 定义一个完整的类方法,需要六个步骤,也就是六大部分。也因为这六个部分的不同而可以大概分为9种方法。 这是我一整天作图整理出来的。可能有些漏缺错误,希望大家能帮忙纠正。让我明白哪里错了,这是对我这个初学者...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 1,234,405
精华内容 493,762
关键字:

在一个类中可能出现三种方法