java——封装与多线程基础

Class1:

句柄 = 值的地址 (堆中地址)
引用地址是栈中地址，值的地址是堆中地址，在传递参数的过程中，相当于把参数的地址传输到方法中（属于一种浅拷贝）
在A方法中无论写任何代码，都没有办法改变B方法中声明的变量的指向，但在A方法中可以改变堆区域中
引用类型的指向（指针的原理相同）
实例：

public class PersonTest{
	public static void main(String[] args){
		Person person1 = new Person();
		Person person2 = new Person();
		person1.age = 21;
		person1.height = 180;
		person1.name = "李明";
		person2.age = 20;
		person2.height = 164;
		person2.name = "李华";
		Person person3 = person1;
		person1 = person2;
		person2 = person3;
		System.out.println(person1.name);
		m1(person1,person2);
		System.out.println(person1.name);
		m2(person1,person2);
		System.out.println(person1.name);
		int w1 = 9;
		int w2 = w1;
		person1.age = w1;
		System.out.println(person1.age);
	}
	public static void m1(Person x,Person y){
		Person z = x;
		x = y;
		y = z;
		System.out.println(x.name);
	}
	public static void m2(Person x,Person y){
		String z = x.name;
		x.name = y.name;
		y.name = z;
		System.out.println(x.name);
	}
}

当main方法中完成交换person1、person2的操作之后，main方法的栈图如下:

进入m1方法之后的栈图如下:

执行完交换操作后如下:

随后m1方法出栈，m2方法入栈:

堆内存图:

代码执行后:

m2方法出栈，main方法进行压栈

执行person1.age = w1;后最终整个堆栈内存图如下:

面向对象的四个特性:
封装，更改器与访问器保证多线程下数据相互干扰问题
继承
多态
抽象
访问器里面必须加上深复制处理，才可以保证多线程下不发生互相干扰
私有变量的地址会被保护起来，当对其值进行操作时会拷贝到新的地址上进行操作

Class2:

线程:
线程之间的执行互不等待

N核CPU在同一时刻只能同时执行N个任务

为了保证再次访问线程时知道从何处继续，切换线程时是需要保持状态的，是需要分配空间，有开销的。

实例:

public class Test{
	public static void main(String[] args){
		Thread t1 = new Thread(){
			@Override
			public void run(){
				System.out.println("大家好我是线程1");
			}
		};
		Thread t2 = new Thread(){
			@Override
			public void run(){
				System.out.println("大家好我是线程2");
			}
		};
		t1.start();		//.start() 就绪，并不是立即执行线程
		t2.start();	
	}
}

其中run方法是两个线程的开始，run方法调用其他的方法时，会在线程栈里开辟一个新的子栈，并将其调用的方法的拷贝压入栈中

一个程序可以保持运行状态，则其内部必然存在一个死循环

对上述实例进行如下修改:

public class Test{
	public static void main(String[] args){
		Thread t1 = new Thread(){
			@Override
			public void run(){
				for(;;){
					System.out.println("大家好我是线程1");
				}
			}
		};
		Thread t2 = new Thread(){
			@Override
			public void run(){
				for(;;){
					System.out.println("大家好我是线程2");
				}
			}
		};
		t1.start();		
		t2.start();	
	}
}

得到输出结果如下:

可以发现，两个线程的执行顺序是随机的。

Thread.sleep(N);		//使线程沉睡N毫秒

实例如下:

public class Test{
	public static void main(String[] args){
		Thread t1 = new Thread(){
			@Override
			public void run(){
				for(;;){
					try{
						Thread.sleep(100);	//使线程停止N毫秒
					}catch(Exception e){
					}
					System.out.println("大家好我是线程1");
				}
			}
		};
		Thread t2 = new Thread(){
			@Override
			public void run(){
				for(;;){
					try{
						Thread.sleep(100);
					}catch(Exception e){
					}
					System.out.println("大家好我是线程2");
				}
			}
		};
		t1.start();		
		t2.start();	
	}
}

主线程在创建完子线程后，与子线程没有任何关系，但由于主线程已经处于就绪态且目前主线程的开销较小，所以极大概率会先输出主线程的内容
线程图如下:

简单的多线程使用样例:

public class Person{
	private int[] arr = {23,44,55,66};
	public int[] a(){
		int[] arr2 = new int[arr.length];
		for(int i = 0;i < arr.length;i++){
			arr2[i] = arr[i];
		}
		return arr2;
	}
}


public class Test1{
	public static void main(String[] args){
		Person person1 = new Person();
		Thread t1 = new Thread(){
			@Override
			public void run(){
				int[] xx = person1.a();
				xx[0] = 123;
			}
		};
		Thread t2 = new Thread(){
			@Override
			public void run(){
				int[] xx = person1.a();
			}
		};
		t1.start();
		t2.start();
	}
}

多线程图如下: