Java——多线程基本使用（一）

1.线程：线程是程序执行的一条路径，一个进程中可以包含多条线程
  多线程：多线程并发执行可以提高程序的效率，可以同时完成多项工作
  多线程的并发和并行的区别：
        (1)并行就是两个任务同时运行，如任务A进行时，B任务也在进行.(需要多核CPU)
        (2)并发是指两个任务都请求运行，而处理器只能接受一个任务，就把这两个任务安排轮流进行，但是由于时间间隔较短，能 让人感到两个任务同时进行

Java程序运行原理：Java命令会启动java虚拟机,启动JVM，等于启动了一个应用程序，也就是启动了一个进程。该进程会自动启动一个"主线程",然后主线程去调用某个类的main方法

JVM启动至少启动了垃圾回收线程和主线程，所以是多线程的
     
2.多线程程序的实现方式
         (1)继承Thread
             1)定义一个继承类Thread
             2)重写run()方法
             3)把新线程要做的事写到run方法中
             4)创建线程对象
             5)开启新线程，内部会自动执行run()方法  
             优点：可以直接使用Thread类中的方法
             缺点：如果已经有了父类，就不能使用这种方法
         (2)实现Runnable
             1)定义类实现Runnable接口
             2)实现run方法
             3)把新线程要做的事写在run方法中
             4)创建自定义的Runnable的子类对象
             5)创建Thread对象，传入Runnable
             6)调用start()开启新线程，内部会自动调用Runnable的run()方法
             优点：即使自己定义的线程类有了父类也没有关系，因为有了父类也可以实现接口，而且接口是可以多实现的
             缺点：不能直接使用Thread中的方法，需要先获取到线程对象后，参能得到Thread的方法，代码复杂
     
3.使用匿名内部类实现多线程的两种方式
4.获取线程的名字和设置线程的名字 getName(),setName();
5.获取当前线程的对象        Thread.currentThread()
6.休眠线程,Thread.sleep,控制当前线程休眠若干毫秒
7.守护线程,setDaemon(),设置一个线程为守护线程,该线程不会单独执行，当其他非守护线程都执行结束后，自动退出

 

package pra_20;
public class J_38 {

	/**
	 * @param args
	 * @throws InterruptedException 
	 */
	public static void main(String[] args) throws InterruptedException {
		/*
		//2.实现方式1
		Mythread mt=new Mythread();		//创建thread的子类对象
		mt.start();						//开启线程，并执行run()方法
		for(int i=0;i<1000;i++){	
			System.out.println("三十六变！");
		}
		
		//2.实现方式2
		MyRunnable mr=new MyRunnable();
		Thread t=new Thread(mr);		//将其当作参数传递给Thread的构造函数
		t.start();
		for(int i=0;i<1000;i++){	
			System.out.println("三十三变！");
		}
		
		//3.使用匿名内部类实现多线程的两种方式
		new Thread(){			//继承Thread类
			public void run(){	//重写run方法
				for(int i=0;i<1000;i++){
					System.out.println("123123");
				}
			}
		}.start();	//开启线程
		
		new Thread(new Runnable(){
			public void run(){
				for(int i=0;i<1000;i++){
					System.out.println("321321");
				}
			}
		}).start();
		*/
		//4.获取线程的名字和设置线程的名字
		new Thread(){
			public void run(){	//重写run方法
					System.out.println(this.getName()+"1231230"); //Thread-01231230
			}
		}.start();
		
		new Thread(){
			public void run(){	//重写run方法
					System.out.println(this.getName()+"3213210"); //Thread-13213210
			}
		}.start();
		
		new Thread("ttttt"){	//通过构造方法给线程名赋值
			public void run(){	//重写run方法
					System.out.println(this.getName()+"3213210"); //ttttt3213210
			}
		}.start();
		
		new Thread("ttttt"){
			public void run(){	//重写run方法
				this.setName("rrrrrrrr");	//必须写到方法里
					System.out.println(this.getName()+"3213210"); //rrrrrrrr3213210
			}
		}.start();
		
		//5.获取当前线程的对象
		new Thread(new Runnable(){
			public void run(){
				System.out.println(Thread.currentThread().getName()+"6556554");
			}
		}).start();
		
		System.out.println(Thread.currentThread().getName()); //main,获取主线程的名字
		
		//6.休眠线程
		for (int i = 20;i>=0; i--) {
			Thread.sleep(1000);
			System.out.println("倒计时"+i);
		}
		new Thread(){			//继承Thread类
			public void run(){	//重写run方法
				for(int i=0;i<30;i++){
					try {
						Thread.sleep(2);
					} catch (InterruptedException e) {
						
						e.printStackTrace();
					}
					System.out.println("123123");
				}
			}
		}.start();	//开启线程
		
		//7.守护线程
		Thread th3=new Thread(){
			public void run(){
				for (int i = 0; i < 5; i++) {
					System.out.println(getName()+"1321");
				}
			}
		};
		Thread th4=new Thread(){
			public void run(){
				for (int i = 0; i < 30; i++) {
					System.out.println(getName()+"23333");
				}
			}
		};
		th4.setDaemon(true);	//当传入true，就是设置其为守护线程
		th3.start();
		th4.start();
	}
		
}
//定义一个继承类Thread
class Mythread extends Thread{
	//需重写run()方法
	public void run(){
		for(int i=0;i<1000;i++){	//将要执行的代码写到run方法中
			System.out.println("看完八十二变！");
		}
	}
}
//定义类实现Runnable接口
class MyRunnable implements Runnable{

	@Override
	public void run(){
		for(int i=0;i<1000;i++){	//将要执行的代码写到run方法中
			System.out.println("看完七十二变！");
		}
	}
	
}