java学习（22）线程（1）

拼搏现实的明天。 2021-06-24 15:58 403阅读 0赞

\* 一、进程  
 \*    进程指运行中的应用程序，每个进程都有自己独立的地址空间（内存空间）如用户点击桌面的IE浏览器，就启动了一个进程。  
 \*    操作系统就会为该进程分配独立的地址空间。当用户再次点击左面的IE浏览器，就又启动了一个进程。操作系统将为新进程分配新的独立的地址空间。  
 \*    目前操作系统都支持多进程。（尝试去使用别人的地址空间，被认为是病毒。一般正常软件只会在自己的地址空间运行。）  
 \* 二、线程  
 \*    线程是进程中的一个实体，是被系统独立调动和分派的基本单位，线程自己不拥有系统资源，只拥有一点在运行中必不可少的资源，  
 \*    但它可与同属一个进程的其他线程共享进程所拥有的全部资源。一个线程可以创建和撤销另一个线程，同一进程中的多个线程之间可以并发执行。  
 \*    线程有就绪，阻塞和运行三种基本状态。  
 \*    1.什么是线程？  
 \*      （1）线程是轻量级的进程。  
 \*      （2）线程没有独立的地址空间（内存空间）  
 \*      （3）线程是由进程创建的（寄生在进程中）（例：迅雷进程创建每一个下载的文件，每个文件就是一个线程）  
 \*      （4）一个进程可以拥有多个线程。即多线程编程  
 \*      （5）线程有五种状态  
 \*         a.新建状态（new）  
 \*         b.就绪状态（Runnable）  
 \*         c.运行状态（Running）  
 \*         d.阻塞状态（Blocked）  
 \*         e.死亡状态（Dead）  
 \*         线程刚被创建，会立马进行一个可运行状态，即就绪状态，然后才会进入运行状态。当出现内存不够用，或文件被别人打开等情况，  
 \*         会出现阻塞状态。当发现资源可用时，会进入就绪状态，判断内存等没有问题后，进入运行状态。运行到一定情况下，进入死亡状态。  
 \*    2.线程的用处（“不会使用线程就别说自己学过JAVA”）  
 \*      高并发会用到多线程。只要应用程序涉及到并发，就离不开多线程编程。  
 \*    3.如何使用？  
 \*      在Java中一个类要当做线程来使用有两种方法。  
 \*      （1）继承THread类，并重写run函数。  
 \*      （2）实现Runnable接口，并重写run函数。(由于java是单继承，在某些情况下，一个类可能已经继承了某个父类，所以需要通过调用接口来实现)  
 \*      
 \*    4.Thread 和 Runnable 的区别  
 \*      Thread 和 Runnable 本质上没有任何区别。需要注意点如下：  
 \*      （1）尽可能多使用 Runnable 接口来创建线程。  
 \*      （2）在使用Thread的时候只需要new一个出来，调用start方法即可。

\*      （3）在使用Runnable的时候，需要先new一个实现Runnable的实例，之后用Thread调用。

package com.shuiyixin1;
    
    public class learnJ_013xiancheng {
    
    	/**
    	 * @作者：shuiyixin
    	 * @日期：2018.02.26
    	 * @内容：线程
    	 */
    	public static void main(String[] args) {
    		// TODO Auto-generated method stub
    
    		//1.创建一个Cat013对象
    		//如果采用Cat013 cat013 = new Cat013();会报错：
    		//No enclosing instance of type learnJ_013xiancheng is accessible. Must qualify the allocation with an enclosing instance of type learnJ_013xiancheng (e.g. x.new A() where x is an instance of learnJ_013xiancheng).
    		//意思是：没有任何类型 TestThread 的外层实例可访问。必须用类型 TestThread 的外层实例（例如，x.new A()，其中 x 是 TestThread 的实例）来限定分配。
    		//解决方法1：将外部类实现对象，并调用方法。
    		learnJ_013xiancheng obj = new learnJ_013xiancheng();
    		Cat013 cat013 = obj.new Cat013();
    		cat013.start();
    		//解决方法2：将内部类设置为静态类，因为类中的静态方法不能直接调用动态方法。
    		//只有将某个内部类修饰为静态类，然后才能够在静态类中调用该类的成员变量与成员方法。
    		Dog013 dog013 = new Dog013();
    		
    		Fish013 fish = obj.new Fish013();
    		//创建一个Thread
    		Thread t = new Thread(fish);
    		t.start();
    		
    		/**
    		 * 由于双方都使用了sleep，代码输出如下：
    		 * hello world!1
    		 * hello fish!1
    		 * hello world!2
    		 * hello fish!2
    		 * hello world!3
    		 * hello fish!3
    		 * 如果有一方没有使用sleep，即没有阻塞状态，只要运行到，就会全部优先输出。
    		 * 是否是交替执行，取决于sleep的数值。
    		 * 注意，线程一旦定好，程序员无法控制。
    		 */
    	}
    
    	class Cat013 extends Thread{
    		int times = 0;
    		public void run(){
    			while (times<3) {
    				try {
    					//sleep会让线程进入到Blocked状态并释放资源。
    					Thread.sleep(1000);
    				} catch (InterruptedException e) {
    					// TODO Auto-generated catch block
    					e.printStackTrace();
    				}
    				System.out.println("hello world!" + (times+1));
    				times++;
    				
    			}
    		}
    	}
    	
    	public static class Dog013 extends Thread{
    		public void run(){
    			//System.out.println("hello world!");
    		}
    	}
    	public class Fish013 implements Runnable{
    
    		int times = 0;
    		public void run() {
    			while (times<3) {
    				try {
    					//sleep会让线程进入到Blocked状态并释放资源。
    					Thread.sleep(1000);
    				} catch (InterruptedException e) {
    					// TODO Auto-generated catch block
    					e.printStackTrace();
    				}
    				System.out.println("hello fish!" + (times+1));
    				times++;
    			}
    		}
    	 }
    	public class Bird013 implements Runnable{
    		int n = 0;
    		int res = 0;
    		int times = 0;
    		
    		public void run() {
    			while (times == n ) {
    				try {
    					//sleep会让线程进入到Blocked状态并释放资源。
    					Thread.sleep(1000);
    				} catch (InterruptedException e) {
    					// TODO Auto-generated catch block
    					e.printStackTrace();
    				}
    				res += ++times;
    			}
    			System.out.println("当前结果是：" + res);
    		}
    		public int getN() {
    			return n;
    		}
    		public void setN(int n) {
    			this.n = n;
    		}
    		public int getRes() {
    			return res;
    		}
    		public void setRes(int res) {
    			this.res = res;
    		}
    		public int getTimes() {
    			return times;
    		}
    		public void setTimes(int times) {
    			this.times = times;
    		}
    		
    	}
    }