1.Java线程
1.1. 多线程和多进程
多进程：操作系统能够同时进行多个任务： 每个app(word,播放器，浏览器)可以同时运行
多线程：同一应用程序中哟多个顺序流同时执行
线程是进程中的一部分
1.2. 线程的执行过程：
主要过程:
多线程执行的抢CPU是不规律的，由虚拟机分配
1.3. 创建线程的方法
(1). 方法1：通过run()
定义一个线程类，它继承类Thread并重写其中的run()方法，方法run()成为线程体
由于Java只支持单继承，用这种方法定义的类不能继承其他类
class ThreadOne extends Thread{
public void run(){
for (int i=0; i<100;i++){
System.out.println("thread one--->" + i);
}
}
}
class ThreadTwo extends Thread{
public void run(){
for (int i=0; i<100;i++){
System.out.println("thread two--->" + i);
}
}
}
class Test{
public static void main(String[] args){
// 生成线程类的对象
ThreadOne fo = new ThreadOne();
ThreadTwo ft = new ThreadTwo();
// 启动线程---> 进入Runnable状态---->准备抢CPU
fo.start();
ft.start();
}
}
(2). 方法2： 复写Runnable接口(推荐)
提供一个实现接口Runnable的类作为线程的目标对象，在初始化一个Thread类或者Thread子类的线程对象时，把目标对象传递给这个线程实体，由该目标对象提供线程体
class RunnableImpl implements Runnable{
public void run(){
for (int i=0; i<100;i++){
System.out.println("thread two--->" + i);
}
}
}
class Test{
public static void main(String[] args){
//生成一个Runnable接口实现类的对象
RunnableImpl ri = new RunnableImpl();
//生成一个Thread对象，并将Runnable接口实现类的对象作为参数传递给该Thread对象
Thread t = new Thread(ri);
// 通知thread执行
t.start();
}
}
1.4. 线程的简单控制
中断线程
Thread.sleep():先睡眠，然后继续进入就绪状态，准备抢CPU----记得抛出异常哦，亲
Thread.yield()：让出CPU，然后继续进入就绪状态，准备抢CPU
设置线程的优先级：
getPriority(): 获取优先级
setPriority(): 设置优先级(1-10)
2. Java线程同步synchronized
2.1. 多线程数据安全以及synchronized的使用
多线程共用同一份数据的时候，会出问题
class MyThread implements Runnable{
int i = 100;
public void run(){
while (true){
// 使用synchronized构造同步代码块---this为同步锁
synchronized(this){
// Thread.currentThread()获取当前代码正在哪个线程中运行
System.out.println(Thread.currentThread().getName() + i);
i = i -1;
Thread.yield();
if(i<0){
break;
}
}
}
}
}
class Test{
public static void main(String[] args){
MyThread myThread = new MyThread();
// 生成两个
Thread t1 = new Thread(myThread);
Thread t2 = new Thread(myThread);
t1.setName("thread a");
t2.setName("thread b");
// t1先获得锁，运行，t2等待
// t2然后获得锁，运行，t1等待
t1.start();
t2.start();
}
}
2.2. 深入synchronized关键字
同步锁不是锁的代码块，锁的是this， 只要一个对象获得同步锁，这个对象其他也含有同步锁的代码都不能执行，只能释放后才能执行
没有同步锁的代码块跟同步锁无关，会继续执行，没有影响
class Service {
public void fun1(){
synchronized(this){
try{
Thread.sleep(3*1000)
}
catch(Exception e){
System.out.println(e)
}
System.out.println("fun1")
}
}
public void fun2(){
synchronized(this){
System.out.println("fun2")
}
}
}
class MyThread1 implments Runnable{
private Service service;
public MyThread1(Service serivce){
this.serivce = serivce;
}
public void run(){
service.fun1();
}
}
class MyThread2 implments Runnable{
private Service service;
public MyThread2(Service serivce){
this.serivce = serivce;
}
public void run(){
service.fun2();
}
}
class Test{
public static void main(String[] args){
Service service = new Service();
Thread t1 = new Thread(new MyThread1(service));
Thread t2 = new Thread(new MyThread2(service));
}
}
2.3. 同步方法
同步方法锁住的是this
class Service {
// 同步方法只需要在方法名前加入synchronized即可
public synchronized void fun1(){
try{
Thread.sleep(3*1000)
}
catch(Exception e){
System.out.println(e)
}
System.out.println("fun1")
}
public void fun2(){
synchronized(this){
System.out.println("fun2")
}
}
}
3. Java的数组和类集框架
用于储存一些列相同数据类型的容器
3.1. 数组类型
数组长度一旦声明，不可更改
class Test{
public static void main(String[] args){
// 一维数组的静态声明法
int[] arr = {1,2,5,7,8,10};
arr[3] = 10; // 设置数组元素为新的值
// 打印一维数组元素
for (int i=0; i
System.out.println(arr[i]);
}
// 一维数组的动态声明法
int[] arr = new int[10]; // 初始化为0
// 二位数组的静态声明法
int[][] arr = {{1,2,3},{4,5,6},{7,8,9}};
arr[1][1]; // = 5
// 二位数组的动态声明法
int[][] arr = new int[3][5];
// 打印二位数组
for (int i=0; i
for (int j=0; i
System.out.println(arr[i][j]);
}
}
}
}
3.2. Java的类集框架
1. 类集框架的定义和种类，以及基础结构
类集框架是一组类和结构，位于java.util包中，主要用于储存和管理对象，主要分为三大类：
集合(Set)： 对象不按照特定的方式排序，并且没有重复对象
列表(List): 对象按照索引位置排序，可以有重复对象
映射(dictionary)： 通过键-值对储存(key-value)
类集框架的主体结构
2. ArrayList列表的使用
import java.util.List;
import java.util.ArrayList;
public class Test{
public static void main(String[] args){
// arraylist的长度可以自动扩展，跟数组有区别
// 声明arraylist只能存String类型
ArrayList arraylist = new ArrayList();
// 向arraylist数组添加对象
arraylist.add("a");
arraylist.add("b");
// 从arraylist取对象
String s = arraylist.get(1);
// 打印arraylist数据
for(int i=0; i
String s = arraylist.get(1);
System.out.println(s);
}
// 删除arraylist数据
arraylist(1);
}
}
3. Collection和Iterator接口
Iterator最高层---hasNext() + Next()
Collection接口是Iteator的子接口
Set是Collection接口的子接口
HashSet是Set的实现类
Iterator
Iterator
(1) Collection接口
方法
含义
boolean add(Object 0)
向集合添加对象
void clear()
删除集合的所有对象
boolean isEmpty()
判断集合是否为空
remove(Object o)
从集合中删除一个对象的引用
int size()
返回集合中元素的数组
4.Set和HashSet用法(Collection的实现类)
import java.util.Set;
import java.util.HashSet;
public class Test{
public static void main(String[] args){
HashSet hashset = new HashSet();
Set set = hashset;
boolean b1 = set.isEmpty();
set.add("a");
set.add("b");
set.add("c");
set.add("a"); // 重复元素会忽略
int a = set.size();
set.remove(a);
set.clear();
// 集合取数据---通过迭代器Iterator
// 调用Set对象的Iterator方法，会生成一个迭代器对象，该对象用于遍历整个Set
Iterator it = set.iterator();
while(it.hasNext()){
//取出元素，并将指针向后面挪一位
String s = it.next();
System.out.println(s);
}
}
}
5. Map和HashMap的使用方法
Map
import java.util.Map;
import java.util.HashMap;
public class Test{
public static void main(String[] args){
// 创建hashmap对象，并定义键值对类型
HashMap hasMap = new HashMap();
Map map = hasMap;
map.put("1","a");
map.put("2","b");
map.put("3","c");
map.put("3","e"); // 将会覆盖上面的键值对
int i = map.size();
String s = map.get("3");
}
}
4. equals函数的使用方法
4.1. equals的作用
==的作用：
基本数据类型： 是否相等?
引用数据类型： 是否指向堆内存的同一地址?
class User{
String name;
int age;
}
class Test{
public static void main(String[] args){
User u1 = new User();
User u2 = new User();
User u3 = u1;
boolean b1 = u1 == u2; // false
boolean b2 = u1 == u3; // true
}
}
eqauls的复写
两个对象类型相同(使用instanceof来比较)
两个对象的成员变量的值完全相同
class User{
// String是引用数据类型
String name;
int age;
public User(String name, int age){
this.name = name;
this.age = age;
}
public boolean equals(Object obj){
if(this == obj){
return true;
}
if(obj instanceof User){
User u = (User)obj;
// 这里的equals是Object的
// equals用于比较内容是否相等
if (this.age == u.age && this.name.equals(u.name)){
return true;
}
else{
return false;
}
}
else{
return false;
}
}
}
class Test{
public static void main(String[] args){
User u1 = new User("zahng",12);
User u2 = new User("liu",15);
User u3 = new User("zahng",12);
boolean b1 = u1.equals(u2); // false
boolean b2 = u1.equals(u3); // true
}
}
