精华内容
下载资源
问答
  • 屏障与互斥量、读写锁等不同,它不是用来保护临界区的,而是与条件变量类似,是一种线程之间的同步机制。屏障允许每个线程等待,直到所有合作线程都到达某一点,然后从该点继续执行。pthread_join就是一种屏障,它...

    屏障与互斥量、读写锁等不同,它不是用来保护临界区的,而是与条件变量类似,是一种线程之间的同步机制。屏障允许每个线程等待,直到所有合作线程都到达某一点,然后从该点继续执行。pthread_join就是一种屏障,它允许线程等待直到另一个线程退出。

    #include <pthread.h>
    pthread_barrier_t ; //屏障数据类型
    
    int pthread_barrier_init(pthread_barrier_t *restrict barrier, const pthread_barrierattr_t *restrict attr, unsigned int count);
                                //初始化屏障,attr指定屏障属性,NULL为默认属性 
                                //count指定在允许所有线程继续执行之前,必须到达屏障的线程数目
    
    int pthread_barrier_destroy(pthread_barrier_t *barrier);
                                //撤销屏障
                                    //返回值:成功,返回0 失败则返回错误编码                          
    int pthread_barrier_wait(pthread_barrier_t *barrier);
                        返回值:若成功,返回0或PTHREAD_BARRIER_SERIAL_THREAD; 否则返回错误编号

    调用pthread_barrier_wait的线程在屏障计数未满足条件(计数达到init中登记的数字)时,会进入休眠状态。如果该线程是最后一个调用pthread_barrier_wait的线程,就满足了计数条件,所有线程会被唤醒。第一个返回的线程会返回PTHREAD_BARRIER_SERIAL_THREAD.可以用第一个返回的线程来进行后续的处理工作。
    一旦达到屏障计数,该屏障就可以被重用。不过计数值不会改变,除非先调用pthread_barrier_destroy撤销该屏障,之后在调用pthread_barrier_init重新初始化。

    下面的程序使用屏障实现一个多线程的排序算法,对于随机生成的15个数分为3部分,使用3个线程分别对各部分进行堆排序。当各部分的排序都完成后(此处用屏障进行各线程的同步),在主线程中对三部分进行归并。对于一个多核处理器来说,这样的多线程排序算法显然优于单线程的算法。对于大量数据来说效率能有显著提高,这里设定总数15个的数据量是为了方便观察结果,只要修改程序中的宏定义即可修改数据总量和使用的线程数。

    #include <stdio.h>
    #include <unistd.h>
    #include <stdlib.h>
    #include <pthread.h>
    
    #define NUMS 15
    #define TURN 3
    #define N (NUMS/TURN)
    
    pthread_barrier_t the_barrier;
    pthread_mutex_t lock = PTHREAD_MUTEX_INITIALIZER;
    
    int nums[NUMS];
    
    void adjust(int i, int n, int turn)
    {
        int parent = i;
        int child;
        int temp = nums[i+turn*N];
    
        while(parent*2+1 <= n-1){
            child = parent*2+1;
            if(child != n-1 && nums[child+turn*N] < nums[child+turn*N+1])
                child++;
            if(temp >= nums[child+turn*N])
                break;
            nums[parent+turn*N] = nums[child+turn*N];
            parent = child;
        }
        nums[parent+turn*N] = temp;
    }
    
    void *heap_sort(void *args)
    {
        int turn = (int)args;
    
        for(int i = (N-2)/2; i >= 0; i--)
            adjust(i, N, turn);
    
        pthread_mutex_lock(&lock);
        printf("in thread%d before sort : ", turn);
        for(int i = 0; i < N; i++)
            printf("%d ", nums[i+turn*N]);
        printf("\n");
        pthread_mutex_unlock(&lock);
    
        for(int j = N-1; j > 0; j--){
            int t = nums[0+turn*N];
            nums[0+turn*N] = nums[j+turn*N];
            nums[j+turn*N] = t;
            adjust(0, j, turn);
        }
    
        pthread_mutex_lock(&lock);
        printf("in thread%d after  sort : ", turn);
        for(int i = 0; i < N; i++)
            printf("%d ", nums[i+turn*N]);
        printf("\n");
        pthread_mutex_unlock(&lock);
    
        pthread_barrier_wait(&the_barrier);
    
    }
    
    void merge(int start1, int start2, int end)
    {
        int *a = malloc((end-start1+1)*sizeof(int));
        int k = 0;
        int i = start1;
        int j = start2;
    
        while(i <= start2-1 && j <= end){
            if(nums[i] <= nums[j]){
                a[k] = nums[i];
                k++;
                i++;
            }else{
                a[k] = nums[j];
                k++;
                j++;
            }
        }
    
        while(i <= start2-1){
            a[k] = nums[i];
            k++;
            i++;
        }
        while(j <= end){
            a[k] = nums[j];
            k++;
            j++;
        }
    
        for(i = start1, k = 0; i <= end; i++, k++)
            nums[i] = a[k];
    
    }
    
    int main()
    {
        pthread_barrier_init(&the_barrier, NULL, TURN+1);
    
        srand(getpid());
        printf("before sort : ");
        for(int i = 0; i < NUMS; i++){
            nums[i] = rand()%100 +1; //生成1100之间的随机数
            printf("%d ", nums[i]);
        }
        printf("\n");
    
        pthread_t tid[TURN];
        for(int i = 0; i < TURN; i++)
            pthread_create(&tid[i], NULL, heap_sort, (void*)i);
    
        pthread_barrier_wait(&the_barrier);
    
        int gap = NUMS/TURN;
        for( ; gap < NUMS; gap *= 2){
            int i;
            for(i = 0; i + gap*2 - 1 < NUMS; i += gap*2)
                merge(i, i + gap, i+ gap*2 -1);
            if(i + gap < NUMS)
                merge(i, i + gap, NUMS-1);
        }
    
        printf("after sort : ");
        for(int i = 0; i < NUMS; i++)
            printf("%d ", nums[i]);
        printf("\n");
    
        pthread_mutex_destroy(&lock);
        pthread_barrier_destroy(&the_barrier);
    }

    输出结果

    before sort : 13 30 53 53 47 91 37 54 10 76 89 68 37 20 23 
    in thread0 before sort : 53 47 53 30 13 
    in thread0 after  sort : 13 30 47 53 53 
    in thread2 before sort : 89 68 37 20 23 
    in thread2 after  sort : 20 23 37 68 89 
    in thread1 before sort : 91 76 54 10 37 
    in thread1 after  sort : 10 37 54 76 91 
    after sort : 10 13 20 23 30 37 37 47 53 53 54 68 76 89 91 
    
    展开全文
  • java多线程排序

    热门讨论 2008-07-02 09:37:17
    java多线程排序源程序,三种排序算法。希尔排序,快速排序,堆排序。
  • 多线程排序+快速排序

    万次阅读 2017-05-24 20:07:48
    多线程排序,主要是将整个排序的序列分成若干份,每一个线程排序一份,所以线程排序完成之后,就进行归并,相当于多个有序序列合并成一个有序序列。 这里就需要用到线程屏障,也就是 pthread_barrier 系列函数...

    多线程排序,主要是将整个排序的序列分成若干份,每一个线程排序一份,所以线程排序完成之后,就进行归并,相当于多个有序序列合并成一个有序序列。


    这里就需要用到线程屏障,也就是 pthread_barrier 系列函数。

    屏障,通俗的说就是一个比赛跑步的过程,所以队员就绪了,才能进行比赛。

    多线程排序也是,需要每个线程都是排序完成后,才能进行合并的过程。


    代码:

    #include <cstdio>
    #include <cstring>
    #include <iostream>
    #include <cstdlib>
    #include <sys/time.h>
    #include <pthread.h>
    #include <algorithm>
    using namespace std;
    
    const long MAX = 10000000L;  //数组中最大数
    const long long MAX_NUM = 100000000L;  //排序数
    const int thread = 4;       //线程数
    const int thread_num = MAX_NUM / thread;  //每个线程排序的个数
    
    int num[MAX_NUM];
    int tmp_num[MAX_NUM];
    
    pthread_barrier_t barrier;
    
    /**
     * Initialized Data
     */
    void init()
    {
    	srandom((int)time(NULL));
    	for(int i = 0; i < MAX_NUM; ++i)
    		num[i] = random() % MAX;
    }
    
    /**
     *quick sort function
     */
    void qsorts(int *start, int *end)
    {	
    	int nums = end - start;
    	if(nums > 0)
    	{
    		int index = 0;
    		int flag = start[0];
    		int i = 0, j = nums;
    		while(i != j)
    		{
    			while(j > i && start[j] >= flag)
    				--j;
    			start[index] = start[j];
    			index = j;
    			while(i < j && start[i] <= flag)
    				++i;
    			start[index] = start[i];
    			index = i;
    		}
    		start[index] = flag;
    		qsorts(start, start + (i - 1));
    		qsorts(start + j + 1, end);
    	}
    }
    
    void* work(void *arg)  //线程排序函数
    {
    	long index = (long)arg;
    	qsorts(num + index, num + index + thread_num - 1);
    	pthread_barrier_wait(&barrier);
    	pthread_exit(NULL);
    }
    
    void meger()        //最终合并函数
    {
    	long index[thread];
    	for (int i = 0; i < thread; ++i)
    	{
    		index[i] = i * thread_num;
    	}
    
    	for(long i = 0; i < MAX_NUM; ++i)
    	{
    		long min_index;
    		long min_num = MAX;
    		for(int j = 0; j < thread; ++j)
    		{
    			if((index[j] < (j + 1) * thread_num) 
    				&& (num[index[j]] < min_num))
    			{
    				min_index = j;
    				min_num = num[index[j]];
    			}
    		}
    		tmp_num[i] = num[index[min_index]];
    		index[min_index]++;
    	}
    }
    
    int main(int argc, char const *argv[])
    {
    	init();
    	
    	struct timeval start, end;
    	pthread_t ptid;
    	//printf("%ld %ld\n", num[1], num[2]);
    	gettimeofday(&start, NULL);
    
    	//init pthread and Thread barrier
    	//add 1, total have (thread + 1) threads.
    	pthread_barrier_init(&barrier, NULL, thread + 1);
    	for(int i = 0; i < thread; ++i)
    		pthread_create(&ptid, NULL, work, (void *)(i * thread_num));
    
    	pthread_barrier_wait(&barrier);
    
    	meger();
    	// use one thread to sort
    	// qsorts(num, num + MAX_NUM - 1);
    
    	gettimeofday(&end, NULL);
    	long long s_usec = start.tv_sec * 1000000 + start.tv_usec;
    	long long e_usec = end.tv_sec * 1000000 + end.tv_usec;
    
    	double useTime = (double)(e_usec - s_usec) / 1000000.0;
    	printf("sort use %.4f seconds\n", useTime);
    
    
    	FILE *fp = fopen("result2.txt", "w+");
    	for(long long i = 0; i < MAX_NUM; ++i)
    		fprintf(fp, "%ld ", num[i]);
    
    	return 0;
    }

    当使用单线程排序时:

    sort use 34.0476 seconds

    当使用2线程排序时:

    sort use 19.7711 seconds
    当使用4线程排序时:

    sort use 16.0659 seconds

    当使用8线程排序时:

    sort use 16.8172 seconds

    如果使用STL中的函数的sort,将会更快。




    展开全文
  • 多线程排序算法C语言实现

    千次阅读 2017-04-13 10:42:15
    多线程排序算法C语言实现代码主要实现对八十万个长整型数据的排序;利用8个线程实现,每个线程负责十万给数,数据由rand()函数产生。

    多线程堆排序算法C语言实现

    代码主要实现对八十万个长整型数据的排序;利用8个线程实现,每个线程负责十万个数,数据由rand()函数产生。
    代码如下:

    #include<stdio.h>
    #include<stdbool.h>
    #include<stdlib.h>
    #include<time.h>
    #include<sys/time.h>
    #include<limits.h>
    #include<pthread.h>
    
    #define NTHR 8
    #define NUMNUM 80
    #define TNUM (NUMNUM/NTHR)
    
    long nums[NUMNUM];
    long snums[NUMNUM];
    
    pthread_barrier_t b;
    
    struct heap{
        long array[TNUM+1];
        long heapSize;
    };
    typedef struct heap Heap;
    typedef long index;
    int siftdown(Heap *heap,index i){
        index parent,largchild;
        long siftkey;
        bool spotfound;
        siftkey=heap->array[i];
        parent=i;
        spotfound=false;
        while(2*parent<=heap->heapSize && !spotfound){
            if(2*parent<heap->heapSize && 
                    heap->array[2*parent]<heap->array[2*parent+1]){
                    largchild=2*parent+1;   
                }else{
                    largchild=2*parent;
                }
            if(siftkey<heap->array[largchild]){
                heap->array[parent]=heap->array[largchild];
                parent=largchild;
            }else
                spotfound=true;
        }
        heap->array[parent]=siftkey;
        return 0;
    }
    
    int root(Heap *heap){
        long keyout;
        keyout=heap->array[1];
        heap->array[1]=heap->array[heap->heapSize];
        heap->heapSize=heap->heapSize-1;
        siftdown(heap,1);
        return keyout;
    }
    int removekeys(long n,Heap *heap,long *array){
        index i;
        for(i=n;i>=1;i--){
            heap->array[i]=root(heap);
        }
    }
    int makeHeap(long n,Heap *heap){
        index i;
        heap->heapSize=n;
        for(i=n/2;i>=1;i--)
            siftdown(heap,i);
    }
    
    int checkResult(Heap *heap){
        for(long i=1;i<TNUM+1;i++){
            if(heap->array[i]-heap->array[i-1]<0){
                printf("fail to sort\n");
                exit(1);
            }
        }
        printf("sort succeed!\n");
        return 0;
    }
    
    int printResult(Heap *heap){
        for(long i=1;i<TNUM+1;i++){
            if(i%10==0)
                printf("\n");
            printf("%ld ",heap->array[i]);
        }   
        printf("\n");
        return 0;
    }
    
    int heapSort(long *array,long heapSize){
        int err=0;
        Heap heap;
        heap.array[0]=0;
        for(long i=1;i<heapSize+1;i++)
            heap.array[i]=array[i-1];
        makeHeap(heapSize,&heap);
        removekeys(heapSize,&heap,heap.array);
        //printResult(heap);
        err=checkResult(&heap);
        if(err!=0)
            exit(1);
        //printf("succeed!\n");
        for(long i=1;i<heapSize+1;i++){
            array[i-1]=heap.array[i];
        }
        return err;
    }
    
    void * thr_fn(void *arg){
        long idx=(long)arg;
        int err=0;
        err=heapSort(&nums[idx],TNUM);
        if(err!=0){
            printf("fail to sort");
            exit(1);
        }
        printf("sort finish!\n");
        pthread_barrier_wait(&b);
        return ((void *)0);
    }
    
    int merge(){
        long idx[NTHR];
        long i,minidx,sidx,num;
    
        for(i=0;i<NTHR;i++){
            idx[i]=i*TNUM;
        }
        for(sidx=0;sidx<NUMNUM;sidx++){
            num=INT_MAX;
            for(i=0;i<NTHR;i++){
                if(idx[i]<(i+1)*TNUM && (nums[idx[i]]<num)){
                    num=nums[idx[i]];
                    minidx=i;
                }
            }
            snums[sidx]=nums[idx[minidx]];
            idx[minidx]++;
        }
    }
    
    int main(){
        unsigned long i;
        struct timeval start,end;
        long long startusec, endusec;
        double elapsed;
        int err;
        pthread_t tid;
    
        srandom(1);
        for(i=0;i<NUMNUM;i++){
            nums[i]=rand()%100+1;
        }
    
        gettimeofday(&start,NULL);
        pthread_barrier_init(&b,NULL,NTHR+1);
        for(i=0;i<NTHR;i++){
            err=pthread_create(&tid,NULL,thr_fn,(void *)(i*TNUM));
            if(err!=0)
                printf("can't create thread\n");
        }
        pthread_barrier_wait(&b);
        merge();
        gettimeofday(&end,NULL);
        startusec=start.tv_sec*1000000+start.tv_usec;
        endusec=end.tv_sec*1000000+end.tv_usec;
        elapsed=(double)(endusec-startusec)/1000000.0;
        printf("sort took %.4f seconds\n",elapsed);
        for(i=0;i<NUMNUM;i++)
            printf("%ld\n",snums[i]);
        exit(0);
    }
    

    在主要介绍pthread_barrier_ 函数:

    • 使用屏障需要初始化,pthread_barrier_init 函数在初始化时一般把等待线程数量设置为NTHER+1(申请的线程数量加一),其实是把主线程包含在内了。
      这样做的原因是:如果只同步申请的子线程,那么子线程完成只时不知道主线程是否完成;因此在线程处理函数中每个子线程完成运算之后用pthread_barrier_wait 函数等待,主线程中也等待,这样可以保证,所有的线程都执行到屏障处之后,一起进行下一步运行。
    展开全文
  • 这是一个简单的运用多线程的程序 主要对快速排序等多个算法进行比较
  • 多线程冒泡法排序

    2019-12-05 22:20:01
    java课的课后作业,要求实现数组的多线程冒泡排序并实现可视化,自己写了一个奇偶排序多线程,但效率较低,现在回顾一下老师课上讲的程序。 生成的界面如上 首先实现Button1的功能,生成随机的指定大小的数组 ...

    java课的课后作业,要求实现数组的多线程冒泡排序并实现可视化,自己写了一个奇偶排序的多线程,但效率较低,现在回顾一下老师课上讲的程序。
    左边是生成的数组大小,右边可选择线程
    生成的界面如上
    首先实现Button1的功能,生成随机的指定大小的数组

    private void jButton1ActionPerformed(java.awt.event.ActionEvent evt) {                                         
            // TODO add your handling code here:
            long len=(Long)jFormattedTextField1.getValue();
            int arr[]=new int[(int)len];
            for(int i=0;i<len;i++)
            {
             arr[i]=(int)(Math.random()*10000);
            }
            SortPane.ar=arr;
            
            this.repaint();
        }                  
    

    接着实现选择线程的按钮

        private void jButton2ActionPerformed(java.awt.event.ActionEvent evt) {                                         
            // TODO add your handling code here:
    
            Object value=jSpinner1.getValue();
            int tn= Integer.parseInt(value.toString());
            SortPane.mode=new int[tn];
           BubbleOrder[]bo=new BubbleOrder[tn];
    
            for(int i=0;i<tn;i++)
            {
              bo[i]= new BubbleOrder((SortPane)jPanel1,i,tn,SortPane.ar);
             
            }
       
         try {
                Thread.sleep(500);}catch(Exception e){}
        for(int i=0;i<tn;i++)
            {
              bo[i].start();
             
            }  
        } 
    

    输入的值为tn,最后生成tn个线程
    在SortPane中实现用直线表示数字大小的方法为:

        public void paint(Graphics g) {
            if(ar==null)
             super.paint(g); //To change body of generated methods, choose Tools | Templates.
            else{
                g.setColor(Color.gray);
                
          
          
          float w=this.getSize().width;
          float h=this.getSize().height; 
          g.fillRect(0, 0, this.getSize().width, this.getSize().height);
          g.setColor(Color.red);
          float w1=w/ar.length;
          w1=w1<1?1:(int)(w1+0.5);
          for(int i=0;i<ar.length;i++){
              
          g.drawLine((int)(i*w1), (int)h,(int)(i*w1) ,(int) (h*(1-ar[i]/10000.0)));//drawLine中的4个参数表示两个点的坐标
          }
          
            }
        
        }
    

    最重要的是如何实现多线程的冒泡排序以及使各线程之间同步,假设项目中使用的4个线程的冒泡排序,那么第一个线程排序下标为0,4,8…的数,第二个线程排序下标为1,5,9…的数,由此类推,当四个线程均排到最后一个数时再对最后四个数字进行排序从而找到整个数组中最小的数,找到最小的数之后再对剩下的数组按照相同的方法排序,直到只剩下4个数时用任意一个线程去排序即可得到有序的数组,下面对代码的每一步进行分析。
    1.将主函数中的参数传到各线程中,对于各参数的意义放到后面分析。

     public BubbleOrder(SortPane sp, int id, int tn, int ar[]) {
            this.id = id;
            this.tn = tn;
            ot = (int) Math.pow(tn, 2) - 1;
            this.ar = ar;
            this.sp = sp;
            BubbleOrder.len = ar.length;
    
        }
    

    2.对其进行数组每次排序后对最后四个数排序和对剩下的最后四个数排序的函数sort1进行分析

        void sort1(int len) {
            if (len > tn) {//判断是每次排序的最后找最小值还是对剩下的最后四个数
                for (int k = len - tn; k < len - 1; k++) {//一层for循环找最小值
                    if (ar[k] < ar[k + 1]) {
                        int ls = ar[k];
                        ar[k] = ar[k + 1];
                        ar[k + 1] = ls;
                    }
    
                }
            } else {//两层for循环进行排序
                for (int k = len; k > 0; k--) {
                    for (int j = 0; j < k - 1; j++) {
                        if (ar[j] < ar[j + 1]) {
                            int ls = ar[j];
                            ar[j] = ar[j + 1];
                            ar[j + 1] = ls;
                        }
                    }
                }
                exit = true;
            }
        }
    

    3.再对其中的排序函数进行分析,很容易知道此处的tn为线程数

        void sort(int len) {
            if (id > len - tn) {
                exit = true;//当剩余需排序的长度小于线程数时退出,然后采用单线程排序即可
            }
            for (int k = id; k < len - tn; k = k + tn) {//id是各线程声明的整型数值,表示线程的名字和线程排序的起点
                if (ar[k] < ar[k + tn]) {//将较小的数换到后面
                    int ls = ar[k];
                    ar[k] = ar[k + tn];
                    ar[k + tn] = ls;
                }
            }
        }
    

    3.分析线程里面的run函数
    一个for循环中,首先进行冒泡排序,然后用一个waiting表示当前线程已完成排序,等待其他线程,已完成排序的线程SortPane.get(id)方法得到false,在sortPane中声明的mode数组存储各线程的完成情况,若完成则赋值为1,

            public void run() {
            while (!exit) {
                System.out.print("Thread " + id + "   sorting\r\n");
                sort(len);
                //synchronized(SortPane.ar){
                waiting = true;
                try{
                 System.out.print("Thread " + id + "   waiting\r\n");
                 SortPane.add(id);
                 if(issorted(SortPane.mode))
                 {
                        sort1(len);
                        sp.repaint();
                        BubbleOrder.len--;
                        if (BubbleOrder.len==tn) {//当仅剩下和线程相等的数组时直接用sort1函数排序
                            sort1(len);
                            sp.repaint();
                            break;
                        }
                        SortPane.clear();
                        synchronized (SortPane.ii) {
                            SortPane.ii.notifyAll();
                        }
                 }
                 else
                 {
                     synchronized (SortPane.ii) {                       
                            //  SortPane.ar.notify();
                            if (exit) {
                                break;
                            }
                            SortPane.ii.wait();
                        }
                 }
                    
                } 
                catch (InterruptedException ex) {//好像没啥用
                }
                
    

    此处为SortPane的mode数组,用于表示各线程是否已完成当前线程的排序

      static   int[] mode;
      static   synchronized void add(int id)
        {
            mode[id]=1;
        }
    

    issorted为判断mode数组是否所有数字为1的函数

     boolean issorted(int a[])
        {
            boolean sorted=true;
            for(int i=0;i<a.length;i++)
            {
                if(a[i]!=1) sorted=false;
            }
            return sorted;
        }
    

    最后的效果如下
    在这里插入图片描述
    在这里插入图片描述

    展开全文
  • 多线程排序-真香

    千次阅读 2019-12-25 21:00:17
    ​来源:公众号【编程珠玑】 作者:守望先生 ID:shouwangxiansheng 在《系统编程-多线程》中... 每个线程对其中的一组数据使用库函数提供的快速排序算法 所有线程排序完成后,将每组排序好的数组合并 ...
  • 多线程排序程序

    千次阅读 2017-04-26 22:49:36
    程序描述此程序实现了多线程的数组排序,可将一个数组拆分为两部分交由两个线程来排序,最后由父进程对其总和。
  • 多线程休眠排序算法

    2019-09-27 19:51:54
    //各位英雄,请问下面的排序时间复杂度为多少呢? public class SleepSort { public static void main(String[] args) { int[] ints = {1,4,7,3,8,9,2,6,5}; SortThread[] sortThreads = new SortThread[...
  • 操作系统实验,通过多线程实现 冒泡排序和快速排序算法,直观的现实每种排序的过程
  • 多线程排序

    2013-11-12 17:09:00
    第一届淘宝并发编程比赛-多线程排序性能优化http://ifeve.com/tao-code-match-1/ 在这里看到一道题目,从一个文件里读取字符串,排序,然后写入另一个文件。 用C实现了一下,逻辑比较简单: 1 将文件读取进来放到...
  • 由于最近在学习C++从底层(指针,对象模型,内存管理)再到网络socket编程,多线程编程,数据库编程等方面知识,需要从Java慢慢的迁移过来。这是以前学习Java的学习路线,所以就把原来Java的做的项目全部用C++重新实现...
  • 利用文件映射和多线程技术对大数据文件进行排序排序使用了qsort函数,合并每个线程的排序结果使用了分治算法
  • 归 并 方 式 的 线 程 快 速 排 序算法
  • sort.c: 多线程排序

    2021-06-12 11:19:24
    辅助线程1使用选择排序算法对数组的前半部分排序 辅助线程2使用选择排序算法对数组的后半部分排序 主线程等待辅助线程运行結束后,使用归并排序算法归并子线程的计算结果 本题要求 1: 使用线程参数,消除程序中的...
  • 多线程实现排序算法的比较:希尔排序、快速排序、堆排序。用java语言实现,很经典,需要的可以下载看看!
  • 最近做了个使用多线程来控制算法的动态展示,我用了四种算法。 思想是:使用绘图在四个panel中进行绘图,但是关键字都是他们的共享资源,在不多建立数组的基础上,是他们之间的排序互不干扰。
  • 多线程归并排序

    千次阅读 2017-07-05 12:31:43
    归并排序是典型的分治算法,所以可以用多线程来解决,在Linux平台上进行多线程编程,必须在编译时链接Linuxthread库,如下图所示: 因为比较简单,就直接上代码了,讲各种排序的博客也比较多。 #include #...
  • VC++多线程实现三种排序算法比较----冒泡排序、快速排序、归并排序,很有意思,可以下载看看!
  • 操作系统上机作业--多线程排序

    千次阅读 2018-07-15 23:12:42
    sort.c: 多线程排序 • 主线程创建一个辅助线程 • 主线程使用选择排序算法对数组的前半部分排序 • 辅助线程使用选择排序算法对数组的后半部分排序 • 主线程等待辅助线程运行結束后,使用归并排序算法归并数组的...
  • 如下: #include <pthread.h> #include <iostream> #include <fstream> #include <string> #include <vector> #include <cstdlib> #include <...algori...
  • 基于多线程的并行快速排序算法实现 1. 快速算法(Quick Sort)介绍 快速排序(Quick Sort)是一种经典的排序算法,基于递归实现,由于其实现方式简单可靠、平均时间复杂度为O(nlogn) (最坏情况O(n^2)), 被广泛采用。...
  • ????使用 ThreadGroup,首先创建一个线程组,把创建的子线程都放到这个线程组里,然后循环判断这个线程组的活跃线程数量 是否等于0,不等于0继续,否则代表子线程全部执行完了,进行下一步。
  • 这是一个使用了多线程的快速排序算法的源代码,如果CPU和内存足够,在32位平台下,最大可以对5亿个int数据进行排序(考虑系统本身所需的内存,程序本身运行所需的内存)。 不支持文件。 待排序的数据由程序自动生成...
  • 多线程实现睡眠排序(排序的数非负) 样例输入: 1 5 6 2 3 6 9 样例输出 1 2 3 5 6 6 9 睡眠排序算法见百度。 有能力的可以实现支持负数的排序

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 155,159
精华内容 62,063
关键字:

多线程排序算法