J2C_synchronized_wait_notify_2_互斥锁_条件变量_比较

前言：对比Java与C生产者与消费者

        Java                                                                               C

synchronized  加锁                       pthread_mutex_lock(&mutex);   加锁    pthread_mutex_unlock(&mutex);//解锁

wait:等待，自动释放锁                 pthread_cond_wait(&cond,&mutex); //条件变量阻塞线程,该函数自动对互斥锁解锁
notify：不会释放锁                       pthread_cond_signal(&cond); //通知消费者线程解除阻塞，不会自动释放锁
                              遇线程结束，自动释放锁

 

wait:会释放锁
notify：不会释放锁
线程结束，自动释放锁

/*********************************Java******************************/
import java.util.ArrayList;
import java.util.List;

public class wait_value {
	
    volatile List lists=new ArrayList(); //添加volatile，使t2得到通知

    public void add(Object o) {
	lists.add(o);
    }
    public int size(){
	return lists.size();
    }
   
     public static void main(String[] args) {
	final wait_value c=new wait_value();
	final Object lock=new Object();
	
        /*
         *  线程一
         */		
	new Thread(new Runnable() {
	    public void run() {
		System.out.println("t1启动");
		synchronized (lock) {
		    for(int i=0;i<10;i++){
			c.add(new Object());
			System.out.println("add"+i);
			if(c.size()==5){
			lock.notify(); //会唤醒正在这个对象上等待的某一个线程，不会释放锁
			//lock.notifyAll(); //会唤醒在这个对象上等待的所有线程
			try {
			    lock.wait(); //t1自己得释放锁，让t2继续执行
			} catch (InterruptedException e) {
			    e.printStackTrace();
			}
		    }
		    try {
			Thread.sleep(1000);  //sleep不释放锁
		    } catch (InterruptedException e) {
			e.printStackTrace();
		    }
		}
	    }
	}
    },"t1").start();
	
    /*
     *  线程二
     */		
    new Thread(new Runnable() {
	public void run() {
	    System.out.println("t2启动");
	    synchronized (lock) {
		if(c.size()!=5){
		    try {
			lock.wait(); //线程等待,释放锁
		    } catch (InterruptedException e) {
			e.printStackTrace();
		    }
		}
		System.out.println("t2结束");
		lock.notify(); //唤醒t1
	    }
	}
    },"t2").start();   //线程结束，锁自动释放
}


/***************************************C****************************************/
#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <string.h>
#include <pthread.h>  

typedef struct node  
{
    int data; //数据域
    struct node* next;  //指针域
}Node;

Node* head=NULL;

pthread_mutex_t mutex; //1---线程同步需要互斥锁
pthread_cond_t cond; //1---阻塞线程需要条件变量

/*
    生产者
*/
void* producer(void* arg)
{
    while(1) 
    {
	Node* pnew = (Node*)malloc(sizeof(Node)); //malloc返回值是void*,强制转换(Node*)
	pnew->data = rand()%1000;  //随机取个整数（0-999）
     
	pthread_mutex_lock(&mutex); //加互斥锁
	pnew->next = head;
	head=pnew;
	printf("======producer:%lu,%d\n",pthread_self(),pnew->data); 
	pthread_mutex_unlock(&mutex); //解锁
	
	pthread_cond_signal(&cond); //通知阻塞的消费者线程，解除阻塞

	sleep(rand()%3);  //休息3秒以内，取余数
    }
    return NULL;
}

/*
    消费者
*/
void* custmer(void* arg)
{
    while(1) 
    {
	pthread_mutex_lock(&mutex); //加锁
	if(head==NULL) 
        {
	    pthread_cond_wait(&cond,&mutex); //条件变量阻塞线程,该函数会对互斥锁解锁
	}
	Node* pdel=head;  //因为消费了，删头节点
	head=head->next; 
	printf("--------custmer:%lu,%d\n",pthread_self(),pdel->data);
	free(pdel);  
	pthread_mutex_unlock(&mutex);//解锁
    }
    return NULL;
}

int main(int argc,const char* argv[]) 
{    
    pthread_mutex_init(&mutex,NULL); //2---初始化互斥锁
    pthread_cond_init(&cond,NULL);  //2---初始化条件变量

    pthread_t p1,p2;  
    pthread_create(&p1,NULL,producer,NULL);  //创建生产者线程,第一件事是去抢CPU
    pthread_create(&p2,NULL,custmer,NULL);   //创建消费者线程
  
    pthread_join(p1,NULL); //阻塞回收子线程的pcb
    pthread_join(p2,NULL);

    pthread_rwlock_destroy(&mutex);  //3---释放互斥锁资源
    pthread_cond_destroy(&cond); //3---销毁条件变量

    return 0;   
}

 

mark:学习笔记