public class J_Thread extends Thread{
private int m_threadID;
public J_Thread(int i){
m_threadID = i;
System.out.println("创建线程:" +i);
}
public void run(){
for(int i=0; i<3;i++){
System.out.println("运行线程: " +m_threadID);
try{
Thread.sleep((int)(Math.random() *1000);
}
catch(InterruptedException e){
System.err.println("异常InterruptedException: " +e);
e.printStackTrace();
}
}
}
public static void main(String args[ ]){
new J_Thread(1).start();
new J_Thread(2).start();
System.out.println("方法main结束");
}
}
后台线程例子
public class J_ThreadDaemon extends Thread{
public void run(){
for(int i=0; true ;i++){
System.out.println("线程在运行:"+i);
try{
sleep((int)(Math.random() *1000);
}
catch(InterruptedException e){
System.err.println(e);
}
}
}
public static void main (String args[ ]){
J_ThreadDaemon t = new J_ThreadDaemon();
t.setDaemon(true);
t.start();
if(t.isDaemon())
System.out.println("创建一个后台线程:");
else
System.out.println("创建一个用户线程:");
System.out.println("主方法运行结束");
}
}
线程组:
public class J_Thread{
public static void main(String args[ ]){
System.out.print("方法main所在的线程组含有");
System.out.println(Thread.activeCount() +"个线程");
Thread t = Thread.currentThread();
ThreadGroup tg = t.getThreaGroup();
for(; tg!= null; tg.getParent()){
System.out.print("线程组" +tg.getName());
System.out.print("含有");
System.out.println(tg.g=activeCount() + "个线程");
int n =tg.activeCount();
Thread [] tList =new Thread[n];
int m=tg.enumerate(tList);
for(int i=0;i<m;i++){
System.out.println(" 其中第" +(i+1) +"个线程名为" +tList[i].getName());
}
}
}
}
多线程同步中共享内存的问题:
class J_Experiment{
public static void mb_sleep(long millis){
try{
Thread.sleep(millis);
}
catch(InterruptedException e){
System.err.println("异常InterruptedException :" +e);
e.printStackTrace();
}
}
public static synchronized void mb_methodStatic(int id){
System.out.println("线程" +id+"进入静态同步方法");
mb_sleep(1000);
System.out.println("线程" +id+ "离开静态同步方法");
}
public synchronized void mb_methodSynchronized(int id){
System.out.println("线程" +id+ "进入非静态同步方法");
mb_sleep(1000);
System.out.println("线程" +id+ "离开非静态同步方法");
}
public void mb_method(int id){
System.out.prinln("线程" +id+ "进入非静态非同步方法");
mb_sleep(1000);
System.out.println("线程" +id+ "离开非静态非同步方法");
}
}
public class J_SynchronizedStatic extends Thread{
public int m_ID;
public J_Experiment m_data;
J_SynchronizedStatic(int id){
m_ID=id;
}
public void run(){
System.out.println("运行线程:" +m_ID);
m_data.mb_methodSynchronized(m_ID);
m_data.mb_methodStatic(m_ID);
m_data.mb_method(m_ID);
System.out.println("结束线程" +m_ID);
}
public static void mian(String args[ ]){
int n=2;
J_SynchronizedStatic [] t=new J_SynchronizedStatic[n];
J_Experiment d=new J_Experiment();
for(int i=0;i<n;i++){
t[i]=new J_SynchronizedStatic(i);
t[i].m_data=d;
t[i].start();
}
System.out.println("方法main结束");
}
}
基于类对象的同步语句块
public class J_BlockClass extends Thread{
public static int m_data=0;
public static int m_times=1000;
public int m_ID;
public boolean m_done;
J_BlockClass(int id){
m_ID=id;
}
public void run(){
m_done=false;
int d=((m_ID%2==0)? 1:-1);
System.out.println("运行线程:" +m_ID+"(增量为:" +d+")");
try{
synchronized (Class.forName("J_BlockClass")){
System.out.println("线程:" +m_ID+ "进入同步语句块,m_data=" +m_data);
for(int i=0;i<m_times;i++)
for(int j=0j<m_times;j++)
m_data+=d;
System.out.println("线程:" +m_ID+"离开同步语句块,m_data=" +m_data);
}
}
catch(ClassNotFoundException e){
e.printStackTrace();
System.err.prinln(e);
}
m_done=true;
System.out.println("结束线程:" +m_ID);
}
public static void main(String args[ ]){
J_BlockClass t1= new J_BlockClass(1);
J_BlockClass t2 = new J_BlockClass(2);
t1.m_done=false;
t2.m_done=false;
t1.start();
t2.start();
while(!t1.m_done|| !t2.m_done)//等待两个线程运行结束
;
System.out.println("结果:m_data=" +m_data);
}
}
基于实例对象的同步语句块的例子
class J_Experiment{
public static void mb_sleep(loog millis){
try{
Thread.sleep(millis);
}
catch(InterruptedException e){
System.err.println("异常InterruptedException: " +e);
e.printStackTrace();
}
}
public void mb_method1(int id){
System.out.println("线程" +id+ "进入方法1");
mb_sleep(1000);
System.out.println("线程" +id+ "离开方法1");
}
public void mb_method2(int id){
System.out.println("线程" +id+ "进入方法2");
mb_sleep(1000);
System.out.println("线程" +id+ "离开方法2");
}
}
public class J_BlockData extends Thread{
public int m_ID;
public J_Experiment m_data;
J_BlockData(int id){
m_ID=id;
}
public void run(){
System.out.println("运行线程:" +m_ID);
synchronized(m_data)//实例对象{
System.out.println("进入同步语句块的是线程:"+m_ID);
m_data.mb_method1(m_ID);
m_data.mb_method2(m_ID);
System.out.println("离开同步语句块的是线程:"+m_ID);
}
System.out.println("结束线程:" +m_ID);
}
public static void main(String args[ ]){
int n=2;
J_BlockData[ ] t =new J_BlockData[n];
J_Experiment d= new J_Experiment();
for(int i=0;i<n; i++){
t[i]=new J_BlockData(i);
t[i].m_data=d;
t[i].start();
}
System.out.println("方法main结束");
}
}
阻塞与唤醒wait();notify()或notifyall()
class J_Experiment{
private int m_temperature,m_pressure;
private boolean m_ready=false;
public synchronized void mb_update(int t,int p){
System.out.println("进入更新方法内部:");
if(m_ready){
System.out.println(" 等待数据分析完成...");
try{
wait();//等待;
}
catch(Exception e){
e.printStackTrace();
System.err.println(e);
}
System.out.println(" 继续更新数据...");
m_temperature =t;
m_pressure = p;
System.out.println("更新完成:温度值为" +t+ ", 气压值为:" +p);
m_ready=true;
notify();
}
public synchronized void mb_analyze(){
System.out.println("进入数据分析方法内部:");
if(!=m_ready){
System.out.println(" 等待数据更新完成...");
try{
wait();
}
catch(Exception e){
e.printStackTrace();
System.err.println(e);
}
System.out.println(" 继续分析数据....");
}
int t=m_temperature;
int p= m_pressure;
System.out.println("分析完成:温度值为:" +t+ ", 气压值为:" +p);
m_ready=false;
notify();
}
}
class J_Assistant extends Thread{
J_Experiment m_data;
public J_Assistant(J_Experiment d){
m_data=d;
}
public void run(){
System.out.println("助理线程开始工作");
int i,j,k;
for(k=0;k<3;k++){
i=(int)(Math.random() *1000);
j =(int)(Math.random() *1000);
m_data.mb_update(i,j);
}
System.out.println("助理线程结束工作");
}
}
class J_Analyst extends Thread{
J_Experiment m_data;
public J_Analyst(J_Experiment d){
m_data=d;
}
public void run(){
System.out.println("分析员线程开始工作");
for(int k=0;k<3;k++)
m_data.mb_analyze();
System.out.println("分析员线程结束工作");
}
}
public class J_WaitNotify{
public static void main(String args[ ]){
J_Experiment data= new J_Experiment();
J_Assistant threadA = new J_Assistant(data);
J_Analyst threadB =new J_Analyst(data);
threadA.start();
threadB.start();
System.out.println("方法main结束");
}
}
可能出现死锁问题:
public class J_Lock extends Thread{
public static Object m_objectA = new Object();
public static Object m_objectB = new Object();
J_Lock(String s){
super(s);
}
public static void mb_sleep(){
try{
Thread.sleep((long)(Math.random() *1000);
}
catch(InterruptedException e){
System.out.println("异常InterruptedException :" +e);
e.printStackTrace();
}
}
public void run(){
boolean t =true;
System.out.println(getName() +"开始运行"):
for( ; true;t!=t){
synchronized(t ? m_objectA:m_objectB){
System.out.println(getName() +": " +(t? "对象A" :"对象B") +"被锁住");
mb_sleep();
synchronized(t ? m_objectB:m_objectA){
System.out.println(getName() + ":" +(t ?"对象B" :"对象A") +"被锁住");
mb_sleep();
System.out.println(getName() +": " +(t? "对象B" :"对象A") +"的锁打开");
}
System.out.println((getName() +":" +(t? "对象A":"对象B")+ "的锁打开"):
}
}
}
public static void main(String args[ ]){
J_LOck t1 = new J_LOck("线程1");
J_Lock t2 = new J_Lock("线程2");
t1.start();
t2.start();
}
}