java多线程学习笔记

开始时间 2018年8月12日16:39:02

结束时间 2018年8月12日18:41:02

累计时间 2小时

一： 多线程： 

   java ： 语法和语句： if while for 
   java： 面向对象： 封装 继承 多态
   IO：   操作文件当中的数据：  File 
       集合： 存放数据： 
   多线程： 合理提高CPU的执行效率。 
   

  概念： 
    进程：正在执行的程序，    其实就是应用程序在在内存当中运行时开辟的一片空间。 
    
   线程： 进程当中的一个执行单元，负责程序的运行。 一个进程当中最少有一条线程。 
   一个进程当中也可以有多条线程， 这个应用程序就称之为多线程。 
   
 并发：如果一个进程当中的多条线程同时执行， 就可以支持为并发。 
 
 多线程的作用：  
   合理的提高CPU的执行效率。  
   
   
二： 主线程的介绍： 
 主线程： JVM 启动后，必然有一个执行路径（线程），从main开始， 一直到主方法
 结束，这个线程称之为主线程： 
 
 
 CPU： 计算机核心：大脑 中央处理器; 
     在某一个时刻，只能运行某个引用程序当中某个线程。  CPU不断的切换执行权限，
     切换的速度非常快，我们用肉眼无法识别。
     
     CPU执行权限的分类：随机的。 不固定。
 
三： 线程的实现方式一： 

   继承： Thread；类： 
   
     重写Run方法：  线程对象要想开启一条线程， start 方法。 
     start 方法会自动调用run方法。
     
     为什么重写run方法？ 
     因为Thread类当中提供的run方法，没有实现任何的操作。 返回了
    
  start 方法和  run 方法之间的区别： 
  start方法： 会开启一条新的线程。 
  run方法： 直接调用run方法， 是属于对象的特有的某个方法。 
     
四： 多线程的实现方式二：  
         实现Runnable接口， 重写run方法。 
         
  实现： Runable接口，此时该类不具备线程对象的特点， 
  但是run方法， run方法当中定义的内容，称之为线程任务。 
  
   要想使用对象具备线程特点，需要将线程任务对象作为参数传递给Thread 类。 

  步骤： 
  （1）定义类实现Runnable接口。  避免了单继承的局限。 
  （2）重写run方法。 run定义了线程任务。 同时被执行的代码。 
  （3）创建一个Thread类，然后将Runnable接口的实现类对象作为参数传递。 
  （4）调用start方法， 开启新的线程。 run:
  
  
 五： 面试问题总结： 
 （1）start 方法和 run方法： 
 （2）继承Thread类  或者实现Runnable 接口： 区别
    
    a: 实现Runnable接口，避免了单继承的局限。 
       更加的符合面向对象的特点： 把线程任何和线程对象定义在两个对象当中
       线程任务和线程对象进行了分离。 
       
   b:继承Thread类， 只能单继承。 线程任务和线程对象耦合在一起。  
       创建出来的对象，即封装了线程的任务，又是线程对象。   
       
       建议：使用Runnable方法。   
   
 六：  多线程之间异常机制： 
  
  多条线程之间异常互补干扰。 
  当主线程当中发生了异常，主线程会结束，其他的线程正常运行。 
  当其他的线程当中出现了异常， 对主线程没有影响，主线程正常运行。 
  
  
七： 售票程序： 

         /*       
         100 当第一条线程 获得CPU的执行权， 售票100. 
        Thread-0  97   tickets 已经完成了--操作，但是还没来的急打印，此时cpu的执行权被切走。 
        Thread-0  96   
        Thread-0  95
        Thread-2  98
           
         结果分析： 出现了打印的顺序问题，并不是错误的数据，而是因为，cpu的执行权限随机分配，导致的。 
         
         
         分析最后的结果： 
         Thread-0  0  
        Thread-3  -1
        Thread-2  -2 
        出现了负号票，这就是发生了数据的安全问题。 
         
        多线程出现数据安全的前提 
        （1） 多条线程有共享资源。 
        （2）多条线程多共享的资源进行想过的数学运算。 
         
         
        */ 
    
    
八： 线程的状态：（面试问题）
 （1）新建态：   new Thread(); 
 （2）就绪态： 调用start 方法。 此时线程进入等待队列。 
 （3）运行态： run方法被执行。 
 （4）堵塞/挂起态（冻结）： 当程序运行时候，遇到了 sleep wait join yield 等这样的方法。 
 （5）终止态： run方法被执行完毕。  
     
     
九： 解决数据的安全问题： 
  使用同步块，解决数据的安全问题： 
  语法： 
  synchronized(对象){
      被锁的资源。 
  }
  
  对象： 任意对象：
  作用：
          使用同步块解决数据的安全问题; 

 弊端： 降低了程序的性能。 
 
原理：  
  本质上是给共享的资源上了一把锁。 
   当某条线程获得了CPU 并且获得了锁对象， 此时其他的线程没有获得锁对象，
   只能等待。  
   
   
十： 线程同步的一个前提： 
   
   多个线程在同步的时候，必须使用同一把锁。 
   
 当出现了数据安全问题后，加锁。 
 加锁完成后，数据安全的问题并没有得到解决。 
 原因： 多个线程之间并没有使用同一把锁。 
解决： 多个线程之间要想解决数据安全问题，必须使用同一把锁。 
 
 
 
 复习： 
  （1）实现线程的两种方式：  明白：区别； 
  （2）写售票系统。 
    运行结果分析： 
            错误数据的原因：  
            （1）
            （2）
            
     解决：同步块： 前提。同一把锁。 
     

 

/*
 * 创建一个子线程，完成1-100之间自然数的输出。同样地，主线程执行同样的操作
 * 创建多线程的第一种方式：继承java.lang.Thread类
 */
//1.创建一个继承于Thread的子类
class SubThread extends Thread{
	//2.重写Thread类的run()方法.方法内实现此子线程要完成的功能
	public void run(){
		for(int i = 1;i <= 100;i++){
			System.out.println(Thread.currentThread().getName() +":" + i);
		}
	}
}

public class TestThread {
	public static void main(String[] args) {
		//3.创建子类的对象
		SubThread st1 = new SubThread();
		SubThread st2 = new SubThread();

		//4.调用线程的start()：启动此线程；调用相应的run()方法
		//一个线程只能够执行一次start()
		//不能通过Thread实现类对象的run()去启动一个线程
		st1.start();
		
		//st.start();
		//st.run();
		st2.start();
		
		for(int i = 1;i <= 100;i++){
			System.out.println(Thread.currentThread().getName() +":" + i);
		}
	}
}

/*
 * Thread的常用方法：
 * 1.start()：启动线程并执行相应的run()方法
 * 2.run():子线程要执行的代码放入run()方法中
 * 3.currentThread()：静态的，调取当前的线程
 * 4.getName():获取此线程的名字
 * 5.setName():设置此线程的名字
 * 6.yield():调用此方法的线程释放当前CPU的执行权
 * 7.join():在A线程中调用B线程的join()方法，表示：当执行到此方法，A线程停止执行，直至B线程执行完毕，
 * A线程再接着join()之后的代码执行
 * 8.isAlive():判断当前线程是否还存活
 * 9.sleep(long l):显式的让当前线程睡眠l毫秒
 * 10.线程通信：wait()   notify()  notifyAll()
 * 
 * 设置线程的优先级
 * getPriority() ：返回线程优先值 
   setPriority(int newPriority) ：改变线程的优先级

 */
class SubThread1 extends Thread {
	public void run() {
		for (int i = 1; i <= 100; i++) {
			// try {
			// Thread.currentThread().sleep(1000);
			// } catch (InterruptedException e) {
			// // TODO Auto-generated catch block
			// e.printStackTrace();
			// }
			System.out.println(Thread.currentThread().getName() + ":"
					+ Thread.currentThread().getPriority() + ":" + i);
		}
	}
}

public class TestThread1 {
	public static void main(String[] args) {

		SubThread1 st1 = new SubThread1();
		st1.setName("子线程1");
		st1.setPriority(Thread.MAX_PRIORITY);
		st1.start();
		Thread.currentThread().setName("========主线程");
		for (int i = 1; i <= 100; i++) {
			System.out.println(Thread.currentThread().getName() + ":"
					+ Thread.currentThread().getPriority() + ":" + i);
			// if(i % 10 == 0){
			// Thread.currentThread().yield();
			// }
			// if(i == 20){
			// try {
			// st1.join();
			// } catch (InterruptedException e) {
			// // TODO Auto-generated catch block
			// e.printStackTrace();
			// }
			// }
		}
		System.out.println(st1.isAlive());
	}
}

 

优先级改变的仅仅是概率 ，并不是优先全部执行完毕。

创建多线程的方法一：继承Thread类

三个线程的火车票抢票程序。存在线程的安全问题

 

//模拟火车站售票窗口，开启三个窗口售票，总票数为100张
//存在线程的安全问题
class Window extends Thread {
	static int ticket = 100;

	public void run() {
		while (true) {
			if (ticket > 0) {
				System.out.println(Thread.currentThread().getName() + "售票，票号为："
						+ ticket--);
			} else {
				break;
			}
		}
	}
}

public class TestWindow {
	public static void main(String[] args) {
		Window w1 = new Window();
		Window w2 = new Window();
		Window w3 = new Window();
		
		w1.setName("窗口1");
		w2.setName("窗口2");
		w3.setName("窗口3");
		
		w1.start();
		w2.start();
		w3.start();
		
		
	}

}

static 为了能够让  三个线程共用。

创建多线程的方法二：通过实现的方式

 

/*
 * 创建多线程的方式二：通过实现的方式
 * 
 * 对比一下继承的方式 vs 实现的方式
 * 1.联系：public class Thread implements Runnable
 * 2.哪个方式好？实现的方式优于继承的方式
 *    why?  1 避免了java单继承的局限性
 *          2 如果多个线程要操作同一份资源(或数据)，更适合使用实现的方式
 */

1 避免局限性：  比如一个学生类实现Runnable接口，多个学生的话代码冗余，而且如果学生继承了人的话，无法再去继承

2 

//使用实现Runnable接口的方式，售票
/*
 * 此程序存在线程的安全问题：打印车票时，会出现重票、错票
 */

class Window1 implements Runnable {
	int ticket = 100;

	public void run() {
		while (true) {
			if (ticket > 0) {
//				try {
//					Thread.currentThread().sleep(10);
//				} catch (InterruptedException e) {
//					// TODO Auto-generated catch block
//					e.printStackTrace();
//				}
				System.out.println(Thread.currentThread().getName() + "售票，票号为："
						+ ticket--);
			} else {
				break;
			}
		}
	}
}

public class TestWindow1 {
	public static void main(String[] args) {
		Window1 w = new Window1();
		Thread t1 = new Thread(w);
		Thread t2 = new Thread(w);
		Thread t3 = new Thread(w);
		
		t1.setName("窗口1");
		t2.setName("窗口2");
		t3.setName("窗口3");
		
		t1.start();
		t2.start();
		t3.start();
	}
}

与上面的一个程序相比，多个线程共用一个对象，即共享对象。 

 

下面代码中   Thread 的构造器要求传入一个Runnable对象

实际传的是PrintNum1，  是多态的一种体现。

//1.创建一个实现了Runnable接口的类
class PrintNum1 implements Runnable {
	//2.实现接口的抽象方法
	public void run() {
		// 子线程执行的代码
		for (int i = 1; i <= 100; i++) {
			if (i % 2 == 0) {
				System.out.println(Thread.currentThread().getName() + ":" + i);
			}
		}
	}
}

public class TestThread1 {
	public static void main(String[] args) {
		//3.创建一个Runnable接口实现类的对象
		PrintNum1 p = new PrintNum1();
//		p.start();
//		p.run();
		//要想启动一个多线程，必须调用start()
		//4.将此对象作为形参传递给Thread类的构造器中，创建Thread类的对象，此对象即为一个线程
		Thread t1 = new Thread(p);
		//5.调用start()方法：启动线程并执行run()
		t1.start();//启动线程；执行Thread对象生成时构造器形参的对象的run()方法。
		
		//再创建一个线程
		Thread t2 = new Thread(p);
		t2.start();
	}
}

底层原理：

调用  thread类里面的 run方法 执行当前对象的run方法

 

在构造器传入的时候给target 赋值，所以调用的run方法是传入的对象的run方法

 

 

2018年8月12日18:42:15 于易动

写的自己感觉很明白了，  不要去刻意追求学习那些设计模式之类的，

疯狂java里面说设计模式的理解要有一定的代码量做基础。

恩恩  不飘。

2018年8月27日21:42:34在易动吧把笔记补上了  还未整理。