多线程知识点1

1、进程的概念：
     进程就是正在执行的程序，一个进程通常就是一个正在执行的应用程序，从windows角度来讲，进程是含有内存和资源并安置
     线程的地方。准确的讲，进程就是一个可执行的程序一次运行的过程，他是系统进程进行资源分配和调度的一个独立的单位。


2、线程的概念：
     线程是程序中的一个执行流，每个线程都有自己的专有寄存器（如栈指针，程序计数器等等），但代码区是共享的，即不用的线程可移植性同样的函数。
     
3、进程和线程的联系：
     ①、一个线程只能属于一个进程，而一个进程可以有多个线程，但至少有一个主线程
     ②、系统资源分配给进程，同一个进程的所有线程共享该进程的所有资源

     ③、线程在执行过程中，需要实现同步，不同进程的线程间要利用消息通信的办法实现同步

     ④、线程是指进程内的一个执行单元，也是进程内的可调度的实体

4、进程和线程的区别：

                   进程                                               线程
调度          拥有资源的基本单位              调度和分配的基本单位


并发性        可以并发执行                        同一个进程的多个线程可以并发执行


拥有资源      拥有资源的独立单位            不拥有系统资源，可共享进程拥有的资源


系统开销      创建会撤销进程时，需要      没有单独的地址空间，开销小
                    分配和回收资源，开销大
              
健壮性        多线程程序更健壮，但切        多线程程序健壮性较差，一个线程死掉则整个进程死掉
                   换进程耗费资源较大

1、多线程的概念
    多线程是指程序中包含多个执行交流，即在一个程序中可以同时运行多个不同的线程来执行不同的任务，也就是说允许单个程序创建多个并行执行的线程来完成各自的任务
    
2、多线程的特性：

   1）、多线程的好处：
       ①、Java支持编写多线程的程序
       ②、多线程最大的好处在于可以同时并发执行多个程序
       ③、多线程可以最大限度低减少CPU闲置时间，从而提高CPU的利用效率
       
   2）、多线程的不利一面
       ①、线程也是程序，所以线程需要占用内存，线程越多占用内存也越多
       ②、线程需要协调和管理，所以需要CUP时间跟踪线程
       ③、线程间共享资源的访问会相互影响，必须解决共享资源的问题
       ④、线程太多会导致控制复杂，最终可能会导致很多BUG
       
3、主线程的概念
      在任何一个Java程序启动时，一个线程立刻运行，他是main方法，这个线程就是程序的主线程
      也就是说，任何Java程序都至少有一个线程，即主线程
   1）、主线程的特殊之处
      ①、他是产生其他线程子线程的线程
      ②、通常他必须最后结束，因为他要执行其他子线程的关闭工作
      
4、线程池的概念：

    线程池类似于操作系统中的缓冲区的概念
    先启动若干数量的线程，并让这些线程都处于睡眠状态，当客户端有一个情求时，就会唤醒线程池中的某一个睡眠线程，让
    他来处理客户端的这个请求，而处理完这个请求后，线程又处于睡眠状态
    
5、Java语言中有两种创建线程对象的方法：
    ①、继承Thread类的方式（要重写其中的run方法）
    ②、实现Runnable接口的方式（建议使用）
    
  Thread类中的run方法本身并不执行任何操作，如果我们重写了run方法，当线程启动时，它将执行run方法。

  Thread类也实现了Runnable接口。

1）、通过继承Thread类
   定义：
public class MyThread extends Thread {

public void run() {
……
}

}
    调用：
MyThread thread = new MyThread();
thread.start();
    
2）、实现Runnable接口的方式
      java.lang.Runnable接口中仅仅只有一个抽象方法：public void run()

也可以通过实现Runnable接口的方式来实现线程，只需要实现其中的run方法即可；
Runnable接口的存在主要是为了解决Java中不允许多继承的问题。

  定义：
public class MyThread implements Runnable{

@Override
public void run() {
……
}

}
  调用：
MyThread r = new MyThread();
//创建一个线程作为外壳，将r包起来，
Thread thread = new Thread(r);
thread.start();    
       
1、线程的优先级
    事实上，计算机只有一个CPU，各个线程轮流获得CPU的使用权，才能执行任务；
 优先级较高的线程有更多获得CPU的机会，反之亦然；
 优先级用整数表示，取值范围是1--10，一般情况下，线程的默认优先级都是5，但是也可以通过 setPriority 和
    getPriority 方法来设置或返回优先级

 1）、Thread类有如下3个静态常量来表示优先级
    ①、MAX_PRIORITY：取值为10，表示最高优先级。
    ②、MIN_PRIORITY：取值为1，表示最底优先级。
    ③、NORM_PRIORITY：取值为5，表示默认的优先级。

Java匿名内部类：

1、匿名内部类的概念
         内部类是指在一个外部类的内部再定义一个类
         匿名内部类也就是没有名字的内部类
         正因为没有名字，所以匿名内部类只能使用一次，它通常用来简化代码编写。
         使用匿名内部类的前提条件是必须继承一个父类或实现一个接口。
         继承抽象类的匿名内部类

abstract Person {
		
	   public abstract void eat();
	   
	}

	public class Demo {
	   public static void main(String[] args) {
	        Person p = new Person() {
	            public void eat() {
	               System.out.println("eat something");
	            }
	        };
	        p.eat();
	    }
	}


    	interface Person {
    		
	    public void eat();
	    
	}
 
	public class Demo {
	     public static void main(String[] args) {
	        Person p = new Person() {
	            public void eat() {
	               System.out.println("eat something");
	            }
	        };
	        p.eat();
	     }
	}

2、使用匿名内部类的注意点。
   ①、不能有构造方法；
   ②、不能定义任何静态成员、方法和类；
   ③、不能是public、protected、private、static
   ④、只能创建匿名内部类的一个实例；
   ⑤、一个匿名内部类一定是在new的后面，用其隐含实现一个接口或实现一个类；
   ⑥、因匿名内部类为局部内部类，所以局部内部类的所有限制都对其生效；
   ⑦、在匿名类中用this时，这个this指的是匿名类本身。如果我们要使用外部类的方法和变量的话，应该加上外部类的类名。
   
3、匿名内部类创建线程
   匿名内部类常用在多线程的实现上，因为要实现多线程必须继承Thread类或是实现Runnable接口。
   
1）、Thread类的匿名内部类实现

public class ThreadDemo {
		public static void main(String[] args) {
			Thread thread = new Thread() {
				public void run() {
					for (int i = 1; i <= 5; i++) {
					           System.out.print(i + " ");
					}
				}
			};
			thread.start();
		}
	}

        2）、等价的非匿名内部类实现

class MyThread extends Thread {
		public void run() {
			for (int i = 1; i <= 5; i++) {
				System.out.print(i + " ");
			}
		}
	}
	public class ThreadDemo {
		public static void main(String[] args) {
			MyThread thread = new MyThread();
			thread.start();
		}
	}

       3）、Runnable接口的匿名内部类实现

public class RunnableDemo {
		public static void main(String[] args) {
			Runnable r = new Runnable() {
				public void run() {
					for (int i = 1; i <= 5; i++) {
					          System.out.print(i + " ");
					}
				}
			};
			Thread thread = new Thread(r);
			thread.start();
		}
	}

       4）、等价的非匿名内部类实现

class MyThread implements Runnable {
		public void run() {
			for (int i = 1; i <= 5; i++) {
				System.out.print(i + " ");
			}
		}
	}
	
	public class RunnableDemo {
		public static void main(String[] args) {
			MyThread r = new MyThread();
			Thread thread = new Thread(r);
			thread.start();
		}
	}