关于java:Java基础

汇合：对象的容器，实现了对对象进行操作的罕用办法，可实现数组的性能
汇合长度可变，存储援用类型。
数组：长度固定，存储援用类型，根本数据类型。

list：有序，有下标，可反复

 Arraylist，Linkedlist，Vector

set：无序，无下标，不反复

 HashSet->LinkedHashSet,SortedSet->TreeSet

public boolean add(E e)：把给定的对象增加到以后汇合中。

public void clear(): 清空集合中所有的元素。

public boolean remove(E e): 把给定的对象在以后汇合中删除。

public boolean contains(Object obj): 判断以后汇合中是否蕴含给定的对象。

public boolean isEmpty(): 判断以后汇合是否为空。

public int size(): 返回汇合中元素的个数。

public Object[] toArray(): 把汇合中的元素，存储到数组中

过程：零碎中正在运行的一个应用程序；程序的一次启动执行过程。
线程：线程是过程创立的一个实体。
并发 (Concurrency)：同一时刻多个工作交替执行。单核 cpu 实现的多任务就是并发。
并行 (Parallelism)：同一时刻多个工作同时执行。多核 cpu 能够实现并行。
串行：同一时刻多个工作程序执行。

1. 继承 Thread 类

public class Hello extends Thread{
  
   @Override
     public void run(){System.out.println("Thread 类实现了 Runable 接口的 run 办法")
     } 

}
. 不能屡次调用 Thread 中的 start()办法，否则会抛出 IllegalThreadStateException 异样。. 执行 start()办法的程序不代表线程启动的程序，即并不是说，越早调用某个线程的 start()办法，它就能越早的执行其中的 run()办法

2. 实现 Runable 接口

public class ThreadRl{public static void main(String[] args){Hello hello = new Hello();
Thread thread = new ThreaProxy(hello);
thread.start();}
}


pulic class Hello implements Runable{

    private Runable target = null;

    @override
      public void run(){System.ou.println("真正实现多线程调用的是 start0 办法")
      }

public void run(){if(target !=null){target.run();
    }
}
public ThreadProxy(Runable target){this.target = target;}

public void start(){start0();
}

public void start0(){run();
}
}

3. 实现 callable, 重写 call 办法

public class MyThread implements Callable<string>{
    @override
     String call() throws Exception(){return "implements callable"}

继承 Threa 与实现 Runable 的区别：

实现 Runabel 接口方式更加适宜多个线程共享一个资源的状况，并且防止了单继承的限度，倡议应用 Ruanable
Callable 与 Runable 的区别：
Callable 能够在工作完结后提供一个返回值，Runnable 没有这个性能
Callable 中的 call() 办法能够抛出异样，而 Runnable 的 run()办法不能抛出异样

public void satrt() 启动线程

public final void setName(String name) 扭转线程名称，使之与参数 name 雷同

public final void setPriority(int piority) 更改线程的优先级

public final void setDaemon(boolean on) 将该线程标记为守护线程或用户线程

public final void join(long millisec) 期待该线程终止的工夫最长为 millis 毫秒
public void interrupt() 中断线程

public static void static yield() 暂停以后正在执行的线程对象，并执行其余线程
yield, 礼让线程，礼让工夫不确定，不肯定胜利

public static void sleep(long millisec) 在指定的毫秒数内让以后正在执行的线程休眠

public static Thread currentThread() 返回对以后正在执行的线程对象的援用

1.NEW 尚未启动的线程 –>start()
2.RUNABLE 在 Java 虚拟机种执行的线程
2.1.Ready
2.2.Running
3.BLOCKED 被阻塞期待监督锁定的线程（期待进入同步代码块的锁）
4.WATING 正在期待另一个线程执行特定动作的线程（wait(),join(),lockSupport.park()）
5.TIMED-WATING 正在期待另一个线程执行动作达到指定等待时间
6.TERMINATED 已退出的线程

互斥锁
Java 中引入对象互斥锁的概念来保障共享数据操作的完整性
一个线程取得资源的使用权后就会将该资源加锁，应用完后会将其解锁

Synchronized 润饰互斥锁
同步的局限性：导致程序的执行效率低
同步办法（非动态的）的锁能够是 this，也能够是其余对象（要求是同一个对象）
同步办法（动态的）的锁为以后类自身
开释锁
以后线程的同步办法同步代码块执行完结
以后线程在同步代码块同步办法中遇到 break，return
以后线程在同步代码块同步办法中呈现了未解决的 Error 或 Exception 导致异样完结
wait() 开释锁；sleep() 不开释锁；suspend()线程挂起，不开释锁；yield()暂停以后线程，不开释锁
线程同步机制
当有一个线程在对内存进行操作时，其余线程不能够对这个内存地址进行操作
线程死锁
死锁是指多个线程因竞争资源而造成的一种僵局（相互期待），若无外力作用，这些过程都将无奈向前推动。
线程死锁的四个条件：
互斥，占有并期待，非抢占，循环期待
防止死锁的办法：
加锁程序；死锁检测；加锁时限
乐观锁
共享锁 (shared locks) 又称为读锁，简称 S 锁。顾名思义，共享锁就是多个事务对于同一数据能够共享一把锁，都能拜访到数据，然而只能读不能批改
排他锁 (exclusive locks) 又称为写锁，简称 X 锁。顾名思义，排他锁就是不能与其余锁并存，如果一个事务获取了一个数据行的排他锁，其余事务就不能再获取该行的其余锁，包含共享锁和排他锁，然而获取排他锁的事务是能够对数

关于java:Java基础

汇合

Collection：

Collection 汇合罕用办法

多线程

实现多线程的形式：

线程罕用办法：

线程状态：

线程锁：

I/O