1.什么是线程?
程序中一个单一顺序的控制流程。
2.线程与进程的区别?
class Runner1 implements Runables{
public void run()
{
for (int i=0;i<100;i++)
{
System.out.println("Runner1="+i);
}
}
}
public class TestThread1
{
public static void main(String args[])
{
Runner1 r = new Runner1();
Thread t = new Thread(r);
t.start();
for(int i=0;i<100;i++)
{
System.out.println("Main Thread:--"+i);
}
}
}
class Runner extends Thread
{
public void run()
{
for(int i=0;i<100;i++)
{
System.out.println("Runner1="+i);
}
}
}
public class Test{
public static void main(String args[])
{
Runner r = new Runner();
r.start();
}
}
import java.util.*;
class MyThread extends Thread
{
public void run()
{
while(true)
{
System.out.println("==="+new Date()+"===");
try
{
sleep(1000);
}
catch(InterruptedException e)
{
return;
}
}
}
}
public class TestInterrupt
{
public static void main(String args[])
{
MyThread thread = new MyThread();
thread.Start();
try
{
Thread.Sleep(10000);
}
catch(InterruptedException e)
{
}
thread.interrupt();
}
}
import java.util.*;
class MyThread2 extends Thread
{
Mythread2(String s)
{
super(s);
}
public void run()
{
for(int i=0;i<10;i++)
{
System.out.println("I AM"+getName());
}
try
{
sleep(1000);
}
catch(InterruptedException e)
{
return;
}
}
}
public class TestInterrupt
{
public static void main(String args[])
{
MyThread2 t = new MyThread2("t");
t.start();
try
{
t.join();
}
catch(InterruptedException e)
{
}
for(int i=0;i<10;i++)
{
System.out.println("I Am Main Thread");
}
}
}
class Timer{
private static int num=0;
public Synchronized void add(String name)
{
Synchronized(this)
{
num++;
try
{
Thread.sleep(1);
}catch(interruptedException e){}
System.out.println(name+",你是第"+num+"使用Timer的线程");
}
}
}
public class TestSync implements Runnable{
Timer timer = new Timer();
public Static void Mian(String args[])
{
TestSync test = new TestSync();
Thread t1= new Thread(test);
Thread t2 = new Thread(test);
t1.setName("t1");
t2.setName("t2");
t1.start();
t2.start();
}
public void run()
{
timer.add(Thread.currentThread().getName());
}
}
注意:
class TestDeadLock implements Runnable
{
public int flag=1;
Static objec o1 = new object();
Static objec o2 = new object();
public void run()
{
System.out.println("flag="+flag);
if(flag==1)
{
Synchronized(o1)
{
try
{
Thread.sleep(500);
}catch(InterruptedException e){}
Synchronized(o2)
{
System.out.println("1");
}
}
}
if(flag==0)
{
Synchronized(02)
{
try
{
Thread.sleep(500);
}catch(InterruptedExcetpion e){}
Synchronized(01)
{
System.out.prinltn("0");
}
}
}
}
public Static void Main(String args[])
{
TestDeadLock td1 = new TestDeadLock();
TestDeadLock td2 = new TestDeadLock();
td1.flag=1;
td2.flag=0;
Thread t1 = new Thread(td1);
Thread t2 = new Thread(td2);
t1.start();
t2.start();
}
}
public class TT implements Runable
{
int b=100;
public Synchronized void m1() throws Exception
{
b=1000;
Thread.sleep(5000);
System.out.println("b="+b);
}
public void m2() throws Exception
{
Thread.sleep(7500);
b=2000;
System.out.println(b);
}
public void run()
{
try
{
m1();
}
catch(Exception e)
{
e.PrintstackTrace();
}
}
public Static void Main(String args[])
{
TT tt = new TT();
Thread t = new Thread(tt);
t.start();
Thread.sleep(1000);
tt.m2();
}
}
分析:首先,t线程开始执行,进入m1()方法,将b的值改为b=1000,t线程开始sleep(5000);
%产品类
class Goods
{
int id;
Goods(int id)
{
this.id = id;
}
public String toString()
{
return "Goods"+id;
}
}
%放产品的堆栈 相当于一个容器,由于消费者和生产者都要对容器进行操作,因此必须对多个线程共同访问的资源枷锁
class SyncStack
{
int index=0;
Goods arrGoods[] = new Goods[6];%只能放6个产品
%Push(Goods good)往容器中放产品的方法
public Synchronized void Push(Goods good)
{
while(index==arrGoods.length)%如果容器已满,就等待
{
try
{
this.wait();
}catch(InterruptedException e){}
}
this.notify();%否则容器中有空位,放入产品
arrGoods[index]=good;
index++;
}
%Pop()返回的是消费的产品
public synchronized Goods Pop()
{
while(index==0)%如果容器中没有产品了,就等待
{
try
{
this.wait();
}catch(InterruptedException e){}
}
this.notify();%容器中有产品就可以消费产品
index--;
return arrGoods[index];
}
}
%生产者只负责往容器中放入产品
class Producer implements Runnable
{
SyncStack ss = null;
Producer(SyncStack ss)
{
this.ss = ss;
}
public void run()
{
for(int i=0;i<20;i++)
{
Goods goods = new Goods(i);
ss.Push(goods);
System.out.println("生产:"+goods);
try
{
Thread.sleep(1000);
}catch(InterruptedException e){}
}
}
}
%消费者只负责从容器中取走产品
class Consumer implements Runnable
{
SyncStack ss= null;
Consumer(SyncStack ss)
{
this.ss = ss;
}
public void run()
{
for(int i=0;i<20;i++)
{
Goods goods = ss.Pop();
System.out.println("消费"+goods);
try
{
Thread.sleep(2000);
}catch(InterruptedException e){}
}
}
}
public class ProducerConsumer
{
public Static void Main(String args[])
{
SyncStack ss = new SyncStack();
Producer p = new Producer(ss);
Consumer c = new Consumer(ss);
Thread t1 = new Thread(p);
Thread t2 = new Thread(c);
t1.start();
t2.start();
}
}
分析:wait()和sleep()的区别