多线程

并行，相当于并联

并发，宏观上，实则分先后，相当于串联

 

进程与线程的区别 与联系

• 进程：有独立的内存空间，进程中的数据存放空间（堆空间和栈空间）是独立的，至少有一个线程。
• 线程：堆空间是共享的，栈空间是独立的，线程消耗的资源比进程小的多。
• 进程是资源分配的最小单位，线程是最小的执行单位。
• 线程共享进程资源。

因为一个进程中的多个线程是并发运行的，那么从微观角度看也是有先后顺序的，哪个线程执行完全取决于 CPU 的调度，程序员是干涉不了的。而这也就造成的多线程的随机性。

 

多线程,特点,随机性,单核cpu并发一会执行这个线程,一会执行另外一个线程,造成代码随机性的现象,可做多个事情!!!

 

创建新执行线程有两种方法。一种方法是将类声明为 Thread 的子类。该子类应重写 Thread 类的 run 方法。接下来可以分配并启动该子类的实例。如：

class PrimeThread extends Thread {
public void run() {
. . .
}
}
PrimeThread p = new PrimeThread(143);
p.start();

另一种方法是声明实现 Runnable 接口的类。该类然后实现 run 方法。然后可以分配该类的实例，在创建 Thread 时作为一个参数来传递并启动。如：、

class PrimeRun implements Runnable {
public void run() {
. . .
}
}
PrimeRun p = new PrimeRun(143);
new Thread(p).start();
 

start()开启新一个的栈内存（可以把main()当做旧的栈内存），实则执行的是run（）。但若是直接调用run（）则没有开启新栈内存，还在main（）的栈内存中，不是多线程。   

 

实现Runnable接口比继承Thread类所具有的优势：

1. 适合多个相同的程序代码的线程去共享同一个资源。成员变量
2. 可以避免java中的单继承的局限性。
3. 增加程序的健壮性，实现解耦(耦合:类与类之间关系)操作，代码可以被多个线程共享，代码和线程独立。

同步锁的位置问题

对于有循环体的，锁需放在循环体里面，放在外面相当于一个线程就可以走完全部循环

public class DXC {
public static void main(String[] args) {
Window g = new Window();
 
Thread w1 = new Thread(g, "窗口一");
w1.start();
Thread w2 = new Thread(g, "窗口二");
w2.start();
Thread w3 = new Thread(g, "窗口三");
w3.start();
Thread w4 = new Thread(g, "窗口四");
w4.start();
}
}
 
class Window implements Runnable {
static int ticket = 100;
 
@Override
public void run() {
//synchronized (Window.class) {  //xx，，后面的窗口只是在循环体外面等待拿不到锁，一个窗口拿到锁后就直接执行完循环体所有次数了
while (true) {
synchronized (Window.class) {   //每一个窗口都能先进入循环，然后有锁的才能进行判断、执行下一步，走完每一次循环都得再次拿锁
if (ticket <= 0) {
break;
}
System.out.println(Thread.currentThread().getName() + "正在卖第" + ticket-- + "票");
try {
Thread.sleep(30);
} catch (InterruptedException e) {
e.printStackTrace();
}
 
}
}
}
}