corejava学习7(多线程)
Cpu内部是串行的是分时执行，在外面是并行的
多线程
1 继承 Thread类 中public void run()
2 实现 Runnable接口 实现public void run()
|
阻塞状态 |
|
T2阻塞，t1继承运行 |
|
初始状态 |
|
终止状态 |
|
1 等待输入 2 thread。sheep（） 3 t2:t1.join() |
Os选 中
|
可运行状态 |
|
运行状态 |
public class TestThread {
public static void main(String[] args) {
Thread t1=new ThreadA();
Runnable target=new Target();
Thread t2=new Thread(target);
t1.start();
t2.start();
}
}
class ThreadA extends Thread{
public void run(){
for(int i=1;i<=100;i++){
System.out.println(i+" $$$");
try {
Thread.sleep(100);
} catch (InterruptedException e) {}
}
}
}
class Target implements Runnable{
public void run(){
for(int i=1;i<=100;i++){
System.out.println(i+" ###");
try {
Thread.sleep(100);
} catch (InterruptedException e) {}
}
}
}
结果：
1 $$$
1 ###
2 ###
2 $$$
3 ###
3 $$$
4 $$$
4 ###
5 $$$
5 ###
6 ###
6 $$$
7 ###
7 $$$
8 $$$
8 ###
9 $$$
9 ###
10 $$$
10 ###
11 $$$
11 ###
12 $$$
线程:进程中并发的一个顺序执行流程
并发原理:CPU分时间片,多线程交替运行
宏观并行,微观串行
线程三要素:CPU Data Code
多线程间堆空间共享,栈空间独立
创建线程两种方式:继承Thread类,实现Runnable接口
Thread对象代表了一个线程
多线程共同访问了同一个对象(临界资源),如何破坏了不可分割的操作(原子操作),就会造成数据不一致的情况
在Java中,任何对象都有一个互斥锁标记,用来分配给线程.
synchronized(o){} 对o加锁的同步代码块
只有拿到o的锁标记的线程,才能进入对o加锁的同步代码快,退出同步代码块,会自动释放o的锁标记
public synchronized void m(){} 同步方法,对this加锁
哪个线程能拿到对象的锁,哪个线程就能调用对象的同步方法
在Java中,任何对象都有一个锁池,用来存放等待该对象锁标记的线程
一个线程,可以同时拥有多个对象的锁标记,线程阻塞在对象锁池中时,不会释放其所拥有的其他对象的锁标记
在Java中,任何对象都有一个等待队列,用来存放线程
t1对o调用wait方法,必须放在对o加锁的同步代码块中! 1.t1会释放其所拥有的所有锁标记;2.t1会进入o的等待队列
t2对o调用notify/notifyAll方法,也必须放在对o加锁的同步代码块中! 会从o的等待队列中释放一个/全部线程 对t2毫无影响
public class TestProducerConsumer {
public static void main(String[] args) {
MyStack ms=new MyStack();
Thread t1=new Producer(ms);
Thread t2=new Consumer(ms);
t1.start();
t2.start();
}
}
class MyStack{
char[] data=new char[6];
int index=0;
private void print(){
for(int i=0;i<index;i++){
System.out.print(data[i]+" ");
}
System.out.println();
}
public synchronized void push(char c){
while(index==data.length){
try {
this.wait();
} catch (InterruptedException e) {}
}
System.out.print(c+" pushed! ");
data[index]=c;
index++;
this.notifyAll();
print();
}
public synchronized void pop(){
while(index==0){
try {
this.wait();
} catch (InterruptedException e) {}
}
index--;
System.out.print(data[index]+" poped! ");
data[index]=' ';
this.notifyAll();
print();
}
}
class Producer extends Thread{
MyStack ms;
public Producer(MyStack s){
this.ms=s;
}
public void run(){
for(char c='A';c<='Z';c++){
ms.push(c);
}
}
}
class Consumer extends Thread{
MyStack ms;
public Consumer(MyStack s){
this.ms=s;
}
public void run(){
for(int c=1;c<=26;c++){
ms.pop();
}
}
}
public class TestNumberCharPrint {
public static void main(String[] args) {
Object o=new Object();
Thread t1=new NumberThread(o);
Thread t2=new CharThread(o);
t1.start();
t2.start();
}
}
class NumberThread extends Thread{
Object o;
public NumberThread(Object o){
this.o=o;
}
public void run(){
synchronized (o) {
for (int i = 1; i <= 26; i++) {
System.out.println(i * 2 - 1);
System.out.println(i * 2);
o.notifyAll();
try {
if (i!=26) o.wait();
} catch (InterruptedException e) {
}
}
}
}
}
class CharThread extends Thread{
Object o;
public CharThread(Object o){
this.o=o;
}
public void run(){
synchronized (o) {
for (char c = 'A'; c <= 'Z'; c++) {
System.out.println(c);
o.notifyAll();
try {
if (c!='Z') o.wait();
} catch (InterruptedException e) {}
}
}
}
}
结果：
A
1 2
B
3 4
………