http://kitsionchen.javaeye.com UTF-8 Copyright 2003-2008, JavaEye.com http://blogs.law.harvard.edu/tech/rss JavaEye - 做最棒的软件开发交流社区 kitsionchen 作者: kitsionchen  链接：http://kitsionchen.javaeye.com/blog/133865  发表时间: 2007年10月20日

声明：本文系JavaEye网站发布的原创博客文章，未经作者书面许可，严禁任何网站转载本文，否则必将追究法律责任！

package kitsion.util;

/**
 * PriorityQueue class implemented via the binary heap.
 */
public class PriorityQueue<AnyType> extends AbstractCollection<AnyType>
        implements Queue<AnyType> {
    public PriorityQueue() {
        currentSize = 0;
        cmp = null;
        array = (AnyType[]) new Object[DEFAULT_CAPACITY + 1];
    }

    /**
     * Construct an empty PriorityQueue with a specified comparator
     *
     * @param c
     */
    public PriorityQueue(Comparator<? super AnyType> c) {
        currentSize = 0;
        cmp = c;
        array = (AnyType[]) new Object[DEFAULT_CAPACITY + 1];
    }

    /**
     * Construct a PriorityQueue from another Collection
     *
     * @param coll
     */
    public PriorityQueue(Collection<? extends AnyType> coll) {
        cmp = null;
        currentSize = coll.size();
        array = (AnyType[]) new Object[(currentSize + 2) * 11 / 10];

        int i = 1;
        for (AnyType item : coll)
            array[i++] = item;
        buildHeap();
    }

    /**
     * Returns the number of items in this PriorityQueue
     */
    public int size() {
        return currentSize;
    }

    public void clear() {
        currentSize = 0;
    }

    /**
     * Returns an iterator over the elements in this PriorityQueue
     */
    public Iterator<AnyType> iterator() {
        return new Iterator<AnyType>() {
            int current = 0;

            public boolean hasNext() {
                return current != size();
            }

            public AnyType next() {
                if (hasNext())
                    return array[++current];
                else
                    throw new NoSuchElementException();
            }

            public void remove() {
                throw new UnsupportedOperationException();
            }
        };
    }

    /**
     * Returns the smallest item in the priority queue
     */
    public AnyType element() {
        if (isEmpty())
            throw new NoSuchElementException();
        return array[1];
    }

    /**
     * Adds an item to this PriorityQueue.
     */
    public boolean add(AnyType x) {
        if (currentSize + 1 == array.length)
            doubleArray();
        /* 详细注解: 增加堆的当前大小,并设置空结点为新增加的结点 */
        int hole = ++currentSize;

        /* 详细注解: 把x作为负无穷标志,放入位置0 */
        array[0] = x;

        /* 详细注解: 只要父结点中的项大于x,重复执行向上过滤的策略,指将父结点中的项下移到空结点中,然后将空结点上移到父结点 */
        for (; compare(x, array[hole / 2]) < 0; hole /= 2)
            array[hole] = array[hole / 2];

        array[hole] = x;
        return true;
    }

    /**
     * Removes the smallest item in the priority queue.
     */
    public AnyType remove() {

        AnyType minItem = element();
        array[1] = array[currentSize--];
        percolateDown(1);
        return minItem;
    }

    /**
     * 详细注解: percolateDown的一个参数指示空结点的位置,然后空结点中项被移出,开台向下过滤,
     * 当没有左孩子,循环结束,因为偶数大小的堆里的最后一个结点是仅有一个子结点,所以还要在向下过滤 中,进行测试.
     *
     * @param hole
     */
    public void percolateDown(int hole) {
        int child;
        AnyType tmp = array[hole];

        for (; hole * 2 <= currentSize; hole = child) {
            child = 2 * hole;
            if (child != currentSize
                    && compare(array[child + 1], array[child]) < 0)
                child++;
            if (compare(array[child], tmp) < 0)
                array[hole] = array[child];
            else
                break;
        }
        array[hole] = tmp;
    }

    /**
     * 逆序采用向下过滤策略,构造有序堆
     */
    public void buildHeap() {
        for (int i = currentSize / 2; i > 0; i--)
            percolateDown(i);
    }

    // number of elements in heap
    private int currentSize;

    // The heap array
    private AnyType[] array;

    private Comparator<? super AnyType> cmp;

    private static final int DEFAULT_CAPACITY = 100;

    /**
     * Internal method to extend array
     */
    private void doubleArray() {
        AnyType[] newArray;

        newArray = (AnyType[]) new Object[array.length * 2];

        for (int i = 0; i < array.length; i++)
            newArray[i] = array[i];
        array = newArray;
    }

    /**
     * Compares lhs and rhs using comparator if provided by cmp, or the default
     * comarator
     *
     * @param lhs
     * @param rhs
     * @return
     */
    private int compare(AnyType lhs, AnyType rhs) {

        if (cmp == null)
            return ((Comparable) lhs).compareTo(rhs);
        else
            return cmp.compare(lhs, rhs);
    }

}

本文的讨论也很精彩，浏览讨论>>


JavaEye推荐

• 北京: 千橡集团暨校内网诚聘软件研发工程师
• 搜狐网站诚聘Java、PHP和C++工程师

]]> Sat, 20 Oct 2007 21:16:11 +0800 http://kitsionchen.javaeye.com/blog/133865 http://kitsionchen.javaeye.com/blog/133865 kitsionchen 作者: kitsionchen  链接：http://kitsionchen.javaeye.com/blog/127860  发表时间: 2007年09月28日

声明：本文系JavaEye网站发布的原创博客文章，未经作者书面许可，严禁任何网站转载本文，否则必将追究法律责任！

慢慢开始有感觉数学对写程序有很多影响.真后悔上上学期的离散数学和概率老是逃课!!
拜读了云风老大的"泊松分布"联想到要有较好的数学和概率基础才能搞出所谓的随机化算法.
搞一个例子吧:
泊松分布一般适用于发生一次的概率很小事件.例如:一门很容易的考试,结果还是有一两个不及格(失礼了,小弟曾经是其中一个.),还有比如购买彩票等等事件,中奖概率很小的事件.假如中奖概率为14000000:1,假设抽取的号码是随机的而且独立的,如果一个人购买彩票越多,中奖概率增加,但两个人买一样多的彩票,概率不会增加,因为是事件独立的.
当中奖人数的期望为2时的彩票中奖者分布如下所示:
中奖彩票数    0                1            2            3            4            5
概率                0.135     0.271    0.272    0.180    0.090    0.036

为了产生一个泊松分布且期望为a的随机无符号数,可以采用重复产生区间(0,1)中均匀分布的随机数直至乘积小于或等于e^(-a),(引用一本国外有关教材采用的策略)在程序代码中把均匀分布的随机数的对数相加,直至所产生的和小于或等于-a.

代码如下:

package kitsion.util;
/*Random number clas, using a 31-bit
线性同余数算法产生均匀分布(linear congruential generator)
*/
public class Random2
{
    private static final int A = 48271;
    private static final int M = 2147483647;        //=2^31-1,素数
    private    static final int Q = M/A;
    private static final int R = M%A;
    private int state;

    /*
    *Construct this Random object with initial state obtained from system clock.
    */
    public Random2()
    {
        this((int)(System.currentTimeMillis() % Integer.MAX_VALUE));
    }

    /*
    *Construct this Random object with specified initial state.
    *@param initialValue the initial value
    */
    public Random2(int initialValue)
    {
        if(initialValue < 0)
            initialValue += M;
        state = initialValue;
        if(state <= 0)
            state = 1;
    }
   
    /*
    *Return a preudorandom int, and change the initial state.
    */
    public int nextInt()
    {
        int tmpState = A * (state % Q) - R * (state / Q);
        if(tmpState >= 0)
            state = tmpState;
        else
            state = tmpState + M;
        return state;
    }
    /*
    *Return a pseudorandom double in the open range0..1
    *and change the internal state
    *@return the pseudorandom double
    */
    public double nextDouble()
    {
        return (double)nextInt() / M;
    }
    /*
    *Return an int using a Poisson distribution, and change the internal state.
    *@param expectedValue the mean of the distribute
    *@return the pseudorandom int.(柏松分布,由均匀分布产生非均匀分布)
    */
    public int nextPoisson(double expectedValue)
    {
        double limit = -expectedValue;
        double product = Math.log(nextDouble());
        int count;
        for(count = 0; product>limit; count++)
            product += Math.log(nextDouble());
        return count;
    }
     /*
     *Method to swap to elements in an array.
     *@param a an array of objects
     *@param index1 the index of the first object.
     *@param index2 the index of the second object
     */
     private static final <AnyType> void swapReferences(AnyType[] a, int index1, int index2)
    {
        AnyType tmp = a[index1];
        a[index1] = a[index2];
        a[index2] = tmp;
     }
    //Test program
    public static void main(String[] args)
    {
        Random2 r = new Random2();
        for(int i = 0; i < 20; i++)
        {
            System.out.println(r.nextInt());
        }
        int[] dist = new int[10000];
        final int SAMPLES = 1000000;
        for(int i = 0; i < SAMPLES; i++)
            dist[r.nextPoisson(2)]++;
        for(int i = 0; i < 10; i++)
            System.out.println(i + "中奖概率: " + dist[i] / (double)SAMPLES);
    }
}

运行结果:

1379218482
2114803975
920033433
972024383
218788490
1962108491
320201773
1019977024
2100834382
903674888
1602680784
2053224936
555609312
2041315816
1216095188
665329203
488017128
1326661745
1326739355
778084371
0中奖概率: 0.13589
1中奖概率: 0.270387
2中奖概率: 0.270704
3中奖概率: 0.18035
4中奖概率: 0.090164
5中奖概率: 0.036003
6中奖概率: 0.011939
7中奖概率: 0.003439
8中奖概率: 8.86E-4
9中奖概率: 1.95E-4
本文的讨论也很精彩，浏览讨论>>


JavaEye推荐

• 搜狐网站诚聘Java、PHP和C++工程师
• 北京: 千橡集团暨校内网诚聘软件研发工程师

]]> Fri, 28 Sep 2007 11:54:11 +0800 http://kitsionchen.javaeye.com/blog/127860 http://kitsionchen.javaeye.com/blog/127860 kitsionchen 作者: kitsionchen  链接：http://kitsionchen.javaeye.com/blog/124614  发表时间: 2007年09月17日

声明：本文系JavaEye网站发布的原创博客文章，未经作者书面许可，严禁任何网站转载本文，否则必将追究法律责任！

import java.util.Random;
/**
*Maximum continguous subsequence sum algorithm
*连续子序列最大和问题
*/
public class MaxSubSequenceSum
{
    static int seqStart = 0;
    static int seqEnd = -1;
    private static Random rand = new Random( );
   
    /**
    *1.Cubic maximum contiguous subsequence sum algorithm.
    *seqStart and seqEnd respresent the actual best sequence.
    */
    public static int maxSubSum1(int[] a)
    {
        int maxSum = 0;
        for(int i = 0; i < a.length; i++)
            for(int j = i; j < a.length; j++)
            {
                int temp = 0;
                for(int k = i; k <= j; k++)
                    temp += a[k];
                if(temp > maxSum)
                {
                    maxSum = temp;
                    seqStart = i;
                    seqEnd = j;
                }
            }
            return maxSum;
    }

    /**
    *2.Square maximum contiguous subsequence sum algorithm.
    *seqStart and seqEnd represent the actual best sequence
    */
    public static int maxSubSum2(int[] a)
    {
        int maxSum = 0;
        for(int i = 0; i < a.length; i++)
        {
            int temp = 0;
            for(int j = i; j < a.length; j++)
            {
                temp += a[j];
                if(temp > maxSum)
                {
                    maxSum = temp;
                    seqStart = i;
                    seqEnd = j;
                }
            }
        }
        return maxSum;
    }

    /**
    *3.Linear-time maximum contiguous subsequence sum algorithm.
    *seqStart and seqEnd represent the actual best sequence
    */
    public static int maxSubSum3(int[] a)
    {
        int maxSum = 0;
        int temp = 0;
        for(int i = 0, j = 0; j < a.length; j++)
        {
            temp += a[j];
            if(temp > maxSum)
            {
                maxSum = temp;
                seqStart = i;
                seqEnd = j;
            }
            else if(temp < 0)
            {
                i = j+1;
                temp = 0;
            }
        }
        return maxSum;
    }

    /**
    *4.Use divide-and-conquer method maximum contiguous
    *subsequence sum algorithm.
    */
    public static int maxSubSumRec(int[] a, int left, int right)
    {
        int maxLeftBorderSum = 0;
        int maxRightBorderSum = 0;
        int leftBorderSum = 0;
        int rightBorderSum = 0;

        int center = (left+right)/2;

        if(left == right)        //only have a number
            return a[left] > 0 ? a[left] : 0;
       
        int maxLeftSum = maxSubSumRec(a, left, center);
        int maxRightSum = maxSubSumRec(a, center+1, right);

        for(int i = center; i >= left; i--)
        {
            leftBorderSum += a[i];
            if(leftBorderSum > maxLeftBorderSum)
                maxLeftBorderSum = leftBorderSum;
        }

        for(int i = center+1; i <= right; i++)
        {
            rightBorderSum += a[i];
            if(rightBorderSum > maxRightBorderSum)
                maxRightBorderSum = rightBorderSum;
        }

        return ThreeOfMax(maxLeftSum,maxRightSum,
            (maxLeftBorderSum+maxRightBorderSum));
    }

    private static int ThreeOfMax(int a, int b, int c)
    {
        return a>b ? a>c ? a : c : b>c ? b : c;
    }

    public static int maxSubSum4(int[] a)
    {
        return a.length > 0 ? maxSubSumRec(a, 0, a.length-1) : 0;
    }
    public static void getTimingInfo(int n, int algorithm)
    {
        int[] test = new int[n];
        long startTime = System.currentTimeMillis();
        long totalTime = 0;
        int i;
        for(i = 0; totalTime < 4000; i++)
        {
            for(int j = 0; j < test.length; j++)
                test[j] = rand.nextInt(100) - 50;
            switch(algorithm)
            {
                case 1:
                    maxSubSum1(test);
                    break;
                case 2:
                    maxSubSum2(test);
                    break;
                case 3:
                    maxSubSum3(test);
                    break;
                case 4:
                    maxSubSum4(test);
                    break;
            }
            totalTime = System.currentTimeMillis() - startTime;
        }
        System.out.println("Algorithm-->" + algorithm
            + "\tN= " + test.length + "\t"
            + "\tTime= " + (totalTime*1000/i) + " ms");       
    }

    /**Simple test programe*/
    public static void main(String[] args)
    {
        int a[] = {4,-3,5,-2,-1,2,6,-1};
        int maxSum;
        maxSum = maxSubSum1(a);
        print(maxSum);

        maxSum = maxSubSum2(a);
        print(maxSum);

        maxSum = maxSubSum3(a);
        print(maxSum);

        maxSum = maxSubSum4( a );
        System.out.println( "Max sum is " + maxSum );

        for(int n = 10; n <=10000000; n*=10)
       
            for(int algorithm = 4; algorithm >= 1; algorithm--)
            {
                if(algorithm == 1 && n > 50000)
                    continue;
                getTimingInfo(n, algorithm);
            }
    }

    private static void print(int maxSum)
    {
        System.out.println( "Max sum is " + maxSum + "; it goes"
                       + " from " + seqStart + " to " + seqEnd );
    } 
}

Answer:
Algorithm-->4   N= 10           Time= 1 ms
Algorithm-->3   N= 10           Time= 0 ms
Algorithm-->2   N= 10           Time= 1 ms
Algorithm-->1   N= 10           Time= 2 ms
Algorithm-->4   N= 100          Time= 20 ms
Algorithm-->3   N= 100          Time= 8 ms
Algorithm-->2   N= 100          Time= 31 ms
Algorithm-->1   N= 100          Time= 709 ms
Algorithm-->4   N= 1000         Time= 219 ms
Algorithm-->3   N= 1000         Time= 81 ms
Algorithm-->2   N= 1000         Time= 2214 ms
Algorithm-->1   N= 1000         Time= 600428 ms
Algorithm-->4   N= 10000                Time= 2368 ms
Algorithm-->3   N= 10000                Time= 814 ms
Algorithm-->2   N= 10000                Time= 222222 ms

本文的讨论也很精彩，浏览讨论>>


JavaEye推荐

• 北京: 千橡集团暨校内网诚聘软件研发工程师
• 搜狐网站诚聘Java、PHP和C++工程师

]]> Mon, 17 Sep 2007 07:51:43 +0800 http://kitsionchen.javaeye.com/blog/124614 http://kitsionchen.javaeye.com/blog/124614 kitsionchen 作者: kitsionchen  链接：http://kitsionchen.javaeye.com/blog/124615  发表时间: 2007年09月16日

声明：本文系JavaEye网站发布的原创博客文章，未经作者书面许可，严禁任何网站转载本文，否则必将追究法律责任！

在这个教程中，Ian Shields 将继续帮助您准备参加 Linux Professional Institute 的初级管理（LPIC-1）考试 102。这是 9 篇系列教程中的第 6 篇。在本教程中，Ian 将向您介绍管理任务。在学完本教程之后，您将掌握如何管理用户和组、设置用户配置文件和环境、使用日志文件、调度作业、备份数据和维护系统时间。
本文的讨论也很精彩，浏览讨论>>


JavaEye推荐

• 北京: 千橡集团暨校内网诚聘软件研发工程师
• 搜狐网站诚聘Java、PHP和C++工程师

]]> Sun, 16 Sep 2007 23:54:48 +0800 http://kitsionchen.javaeye.com/blog/124615 http://kitsionchen.javaeye.com/blog/124615 kitsionchen 作者: kitsionchen  链接：http://kitsionchen.javaeye.com/blog/124616  发表时间: 2007年09月16日

声明：本文系JavaEye网站发布的原创博客文章，未经作者书面许可，严禁任何网站转载本文，否则必将追究法律责任！

通过本文，了解更多有关 libhugetlbfs 库以及如何将这些库与 GNU Compiler Collection (GCC) 或 IBM XL C/C++ 及 XL Fortran compilers for Linux(R) 结合使用的信息。libhugetlbfs 是一个开源社区项目，可为客户应用程序提供到系统大内存页的透明访问。SUSE Linux Enterprise Server 10 (SLES 10) 和 Red Hat Enterprise Server Linux 5 (RHEL 5) 现均支持 libhugetlbfs。尽管大量支持 Linux 大内存页的硬件平台也都支持 libhugetlbfs，但本文只侧重于介绍基于 IBM POWER 处理器的系统上的 16MB 大内存页支持。
本文的讨论也很精彩，浏览讨论>>


JavaEye推荐

• 搜狐网站诚聘Java、PHP和C++工程师
• 北京: 千橡集团暨校内网诚聘软件研发工程师

]]> Sun, 16 Sep 2007 23:54:47 +0800 http://kitsionchen.javaeye.com/blog/124616 http://kitsionchen.javaeye.com/blog/124616 kitsionchen 作者: kitsionchen  链接：http://kitsionchen.javaeye.com/blog/124617  发表时间: 2007年09月16日

声明：本文系JavaEye网站发布的原创博客文章，未经作者书面许可，严禁任何网站转载本文，否则必将追究法律责任！

假设您需要在深夜里运行 30 分钟某些 trace 程序以调试一个棘手的问题，或者您希望将 Linux 系统当作闹钟使唤。本文介绍的技巧将帮助您在运行一段时间（或满足其他条件）后停止执行某些作业，例如使用 cron 和 at 功能启动的作业。
本文的讨论也很精彩，浏览讨论>>


JavaEye推荐

• 搜狐网站诚聘Java、PHP和C++工程师
• 北京: 千橡集团暨校内网诚聘软件研发工程师

]]> Sun, 16 Sep 2007 23:54:46 +0800 http://kitsionchen.javaeye.com/blog/124617 http://kitsionchen.javaeye.com/blog/124617 kitsionchen 作者: kitsionchen  链接：http://kitsionchen.javaeye.com/blog/124618  发表时间: 2007年09月16日

声明：本文系JavaEye网站发布的原创博客文章，未经作者书面许可，严禁任何网站转载本文，否则必将追究法律责任！

IBM POWER5(TM) 和 POWER5+(TM) 系统提供了非常优秀的虚拟化能力。通过阅读本文，您将理解影响运行 SUSE Linux Enterprise Server (SLES) 10 的 IBM POWER5 系统虚拟化性能的因素，并学习如何使用一些可以帮助诊断和解决性能问题的工具。您还将看到几个如何测试和改进性能的例子。
本文的讨论也很精彩，浏览讨论>>


JavaEye推荐

• 北京: 千橡集团暨校内网诚聘软件研发工程师
• 搜狐网站诚聘Java、PHP和C++工程师

]]> Sun, 16 Sep 2007 23:54:46 +0800 http://kitsionchen.javaeye.com/blog/124618 http://kitsionchen.javaeye.com/blog/124618 kitsionchen 作者: kitsionchen  链接：http://kitsionchen.javaeye.com/blog/124619  发表时间: 2007年09月16日

声明：本文系JavaEye网站发布的原创博客文章，未经作者书面许可，严禁任何网站转载本文，否则必将追究法律责任！

本系列文章详细地介绍了一个Linux下的全新的调式、诊断和性能测量工具Systemtap和它所依赖的基础kprobe以及促使开发该工具的先驱DTrace并给出实际使用例子使读者更进一步了解和认识这些工具。 本文是该系列文章之三，它讲解了Systemtap的原理，Systemtap与DTrace比较，以及安装要求和安装步骤，最后通过一个例子向读者展示Systemtap的工作机理。本系列文章之一讲解了kprobe的原理、编程接口、局限性和使用注意事项并给出实际使用示例帮助读者理解和认识kprobe。本系列文章之二讲解了DTrace的原理。
本文的讨论也很精彩，浏览讨论>>


JavaEye推荐

• 北京: 千橡集团暨校内网诚聘软件研发工程师
• 搜狐网站诚聘Java、PHP和C++工程师

]]> Sun, 16 Sep 2007 23:54:45 +0800 http://kitsionchen.javaeye.com/blog/124619 http://kitsionchen.javaeye.com/blog/124619 kitsionchen 作者: kitsionchen  链接：http://kitsionchen.javaeye.com/blog/124620  发表时间: 2007年09月16日

声明：本文系JavaEye网站发布的原创博客文章，未经作者书面许可，严禁任何网站转载本文，否则必将追究法律责任！

你是不是经常需要远程登录到Linux服务器？你是不是经常为一些长时间运行的任务头疼？还在用 nohup 吗？那么来看看 screen 吧，它会给你一个惊喜！
本文的讨论也很精彩，浏览讨论>>


JavaEye推荐

• 北京: 千橡集团暨校内网诚聘软件研发工程师
• 搜狐网站诚聘Java、PHP和C++工程师

]]> Sun, 16 Sep 2007 23:54:45 +0800 http://kitsionchen.javaeye.com/blog/124620 http://kitsionchen.javaeye.com/blog/124620 kitsionchen 作者: kitsionchen  链接：http://kitsionchen.javaeye.com/blog/124621  发表时间: 2007年09月16日

声明：本文系JavaEye网站发布的原创博客文章，未经作者书面许可，严禁任何网站转载本文，否则必将追究法律责任！

本系列文章详细地介绍了一个Linux下的全新的调式、诊断和性能测量工具Systemtap和它所依赖的基础kprobe以及促使开发该工具的先驱DTrace并给出实际使用例子使读者更进一步了解和认识这些工具。 本文是该系列文章之一，它讲解了kprobe的原理、编程接口、局限性和使用注意事项并给出实际使用示例帮助读者理解和认识kprobe。本系列文章之二讲解了DTrace以及Systemtap与DTrace比较。本系列文章之三讲解了Systemtap的原理，并通过一个例子向读者展示Systemtap的工作机理。
本文的讨论也很精彩，浏览讨论>>


JavaEye推荐

• 搜狐网站诚聘Java、PHP和C++工程师
• 北京: 千橡集团暨校内网诚聘软件研发工程师

]]> Sun, 16 Sep 2007 23:54:44 +0800 http://kitsionchen.javaeye.com/blog/124621 http://kitsionchen.javaeye.com/blog/124621 kitsionchen 作者: kitsionchen  链接：http://kitsionchen.javaeye.com/blog/124622  发表时间: 2007年09月16日

声明：本文系JavaEye网站发布的原创博客文章，未经作者书面许可，严禁任何网站转载本文，否则必将追究法律责任！

您是否有时想知道如何对脚本使用参数，以及如何将参数传递给内部函数或其他脚本？是否需要对参数或选项做一些简单的有效性测试？或者对参数字符串执行一些简单的析取和替换操作？本文将向您介绍参数的用法和 bash shell 中的各种参数扩展。
本文的讨论也很精彩，浏览讨论>>


JavaEye推荐

• 搜狐网站诚聘Java、PHP和C++工程师
• 北京: 千橡集团暨校内网诚聘软件研发工程师

]]> Sun, 16 Sep 2007 23:54:44 +0800 http://kitsionchen.javaeye.com/blog/124622 http://kitsionchen.javaeye.com/blog/124622 kitsionchen 作者: kitsionchen  链接：http://kitsionchen.javaeye.com/blog/124623  发表时间: 2007年09月16日

声明：本文系JavaEye网站发布的原创博客文章，未经作者书面许可，严禁任何网站转载本文，否则必将追究法律责任！

系统管理员需要在系统负载低的午夜运行作业，或者需要每天或每周运行作业，同时又不愿意牺牲睡眠时间或假期。调度任务的其他原因包括自动执行日常任务或者确保每次都以相同的方式处理任务。本文帮助您使用 cron 和 at 功能调度作业定期运行或在指定的时间运行一次。
本文的讨论也很精彩，浏览讨论>>


JavaEye推荐

• 搜狐网站诚聘Java、PHP和C++工程师
• 北京: 千橡集团暨校内网诚聘软件研发工程师

]]> Sun, 16 Sep 2007 23:54:43 +0800 http://kitsionchen.javaeye.com/blog/124623 http://kitsionchen.javaeye.com/blog/124623 kitsionchen 作者: kitsionchen  链接：http://kitsionchen.javaeye.com/blog/124624  发表时间: 2007年09月16日

声明：本文系JavaEye网站发布的原创博客文章，未经作者书面许可，严禁任何网站转载本文，否则必将追究法律责任！

如今，开发人员不断地开发和部署使用 LAMP（Linux、Apache、MySQL 和 PHP/Perl）架构的应用程序。但是，服务器管理员常常对应用程序本身没有什么控制能力，因为应用程序是别人编写的。这份共三部分的系列文章将讨论许多服务器配置问题，这些配置会影响应用程序的性能。本文是本系列文章的第三部分，也是最后一部分，将重点讨论为实现最高效率而对数据库层进行的调优。
本文的讨论也很精彩，浏览讨论>>


JavaEye推荐

• 北京: 千橡集团暨校内网诚聘软件研发工程师
• 搜狐网站诚聘Java、PHP和C++工程师

]]> Sun, 16 Sep 2007 23:54:43 +0800 http://kitsionchen.javaeye.com/blog/124624 http://kitsionchen.javaeye.com/blog/124624 kitsionchen 作者: kitsionchen  链接：http://kitsionchen.javaeye.com/blog/124625  发表时间: 2007年09月16日

声明：本文系JavaEye网站发布的原创博客文章，未经作者书面许可，严禁任何网站转载本文，否则必将追究法律责任！

本文简单介绍了IPV6的相关知识，描述了如何通过Hurricane Electric提供的免费IPV6隧道，连接到IPV6网络的方法。
本文的讨论也很精彩，浏览讨论>>


JavaEye推荐

• 搜狐网站诚聘Java、PHP和C++工程师
• 北京: 千橡集团暨校内网诚聘软件研发工程师

]]> Sun, 16 Sep 2007 23:54:42 +0800 http://kitsionchen.javaeye.com/blog/124625 http://kitsionchen.javaeye.com/blog/124625 kitsionchen 作者: kitsionchen  链接：http://kitsionchen.javaeye.com/blog/124626  发表时间: 2007年09月16日

声明：本文系JavaEye网站发布的原创博客文章，未经作者书面许可，严禁任何网站转载本文，否则必将追究法律责任！

GDB 是 linux 系统上常用的调试工具，本文介绍了使用 GDB 调试多进程程序的几种方法，并对各种方法进行比较。
本文的讨论也很精彩，浏览讨论>>


JavaEye推荐

• 搜狐网站诚聘Java、PHP和C++工程师
• 北京: 千橡集团暨校内网诚聘软件研发工程师

]]> Sun, 16 Sep 2007 23:54:42 +0800 http://kitsionchen.javaeye.com/blog/124626 http://kitsionchen.javaeye.com/blog/124626 kitsionchen 作者: kitsionchen  链接：http://kitsionchen.javaeye.com/blog/124627  发表时间: 2007年09月16日

声明：本文系JavaEye网站发布的原创博客文章，未经作者书面许可，严禁任何网站转载本文，否则必将追究法律责任！

Linux 允许众多不同的文件系统共存，并支持跨文件系统的文件操作，这是因为有虚拟文件系统的存在。虚拟文件系统，即VFS（Virtual File System）是 Linux 内核中的一个软件抽象层。它通过一些数据结构及其方法向实际的文件系统如 ext2，vfat 提供接口机制。本文在简要介绍 VFS 的相关数据结构后，以文件 I/O 为切入点深入 Linux 内核源代码，追踪了 sys_open 和 sys_read 两个系统调用的代码结构，并在追踪的过程中理清了跨文件系统的文件操作的基本原理和“一切皆是文件”的口号得以实现的根本。
本文的讨论也很精彩，浏览讨论>>


JavaEye推荐

• 搜狐网站诚聘Java、PHP和C++工程师
• 北京: 千橡集团暨校内网诚聘软件研发工程师

]]> Sun, 16 Sep 2007 23:54:41 +0800 http://kitsionchen.javaeye.com/blog/124627 http://kitsionchen.javaeye.com/blog/124627 kitsionchen 作者: kitsionchen  链接：http://kitsionchen.javaeye.com/blog/124628  发表时间: 2007年09月16日

声明：本文系JavaEye网站发布的原创博客文章，未经作者书面许可，严禁任何网站转载本文，否则必将追究法律责任！

当编写 Shell 程序时，您通常会遇到一些特殊的情况，希望采用自动方式处理。本教程包括一些关于此类情况的 Bourne Shell 脚本示例。这些情况包括字符串的进制转换（十进制到十六进制、十六进制到十进制、十进制到八进制，等等）、在管道循环中读取键盘、Subshell 执行、内联输入、为目录中的每个文件执行一次命令，以及使用多种方法构造连续循环。本系列文章的第 4 部分总结了一批执行有用功能的 Shell 单命令行程序。
本文的讨论也很精彩，浏览讨论>>


JavaEye推荐

• 北京: 千橡集团暨校内网诚聘软件研发工程师
• 搜狐网站诚聘Java、PHP和C++工程师

]]> Sun, 16 Sep 2007 23:54:41 +0800 http://kitsionchen.javaeye.com/blog/124628 http://kitsionchen.javaeye.com/blog/124628 kitsionchen 作者: kitsionchen  链接：http://kitsionchen.javaeye.com/blog/124629  发表时间: 2007年09月16日

声明：本文系JavaEye网站发布的原创博客文章，未经作者书面许可，严禁任何网站转载本文，否则必将追究法律责任！

本教程是含两部分的系列教程的第二部分，这个系列介绍了为何要锁定 Linux机器来理顺相关的支持和管理过程，本教程讲解如何对 Linux 内核进行配置，使其只执行签名的二进制代码。
本文的讨论也很精彩，浏览讨论>>


JavaEye推荐

• 搜狐网站诚聘Java、PHP和C++工程师
• 北京: 千橡集团暨校内网诚聘软件研发工程师

]]> Sun, 16 Sep 2007 23:54:40 +0800 http://kitsionchen.javaeye.com/blog/124629 http://kitsionchen.javaeye.com/blog/124629 kitsionchen 作者: kitsionchen  链接：http://kitsionchen.javaeye.com/blog/124630  发表时间: 2007年09月16日

声明：本文系JavaEye网站发布的原创博客文章，未经作者书面许可，严禁任何网站转载本文，否则必将追究法律责任！

本文全面系统地介绍了shell脚本调试技术，包括使用echo, tee, trap等命令输出关键信息，跟踪变量的值，在脚本中植入调试钩子，使用“-n”选项进行shell脚本的语法检查， 使用“-x”选项实现shell脚本逐条语句的跟踪，巧妙地利用shell的内置变量增强“-x”选项的输出信息等。
本文的讨论也很精彩，浏览讨论>>


JavaEye推荐

• 搜狐网站诚聘Java、PHP和C++工程师
• 北京: 千橡集团暨校内网诚聘软件研发工程师

]]> Sun, 16 Sep 2007 23:54:40 +0800 http://kitsionchen.javaeye.com/blog/124630 http://kitsionchen.javaeye.com/blog/124630 kitsionchen 作者: kitsionchen  链接：http://kitsionchen.javaeye.com/blog/124631  发表时间: 2007年09月16日

声明：本文系JavaEye网站发布的原创博客文章，未经作者书面许可，严禁任何网站转载本文，否则必将追究法律责任！

目前的各种嵌入式产品已经丰富多彩，它们正改变着我们的生活方式。随着嵌入式产品功能的增加，如何让用户对已购买的产品的升级能安全地、顺利地完成，避免升级过程中出现的意外掉电所引起的产品故障，这样的问题要求嵌入产品设计开发者在设计时就将产品的 safe mode 安全模式考虑进去。 这里我们将以一个嵌入式Linux 网络播放器为例，来说明 safe mode 安全模式的设计与实现。通过本文，我们可以了解到针对一个实际的嵌入式系统，设计中需要注意的技术要点和实现细节。
本文的讨论也很精彩，浏览讨论>>


JavaEye推荐

• 北京: 千橡集团暨校内网诚聘软件研发工程师
• 搜狐网站诚聘Java、PHP和C++工程师

]]> Sun, 16 Sep 2007 23:54:39 +0800 http://kitsionchen.javaeye.com/blog/124631 http://kitsionchen.javaeye.com/blog/124631 kitsionchen 作者: kitsionchen  链接：http://kitsionchen.javaeye.com/blog/124632  发表时间: 2007年09月16日

声明：本文系JavaEye网站发布的原创博客文章，未经作者书面许可，严禁任何网站转载本文，否则必将追究法律责任！

GNU 的 gperf 工具是一种 “完美的” 散列函数，可以为用户提供的一组特定字符串生成散列表、散列函数和查找函数的 C/C++ 代码。通过本文学习如何使用 gperf 实现 C/C++ 代码中高效的命令行处理。
本文的讨论也很精彩，浏览讨论>>


JavaEye推荐

• 北京: 千橡集团暨校内网诚聘软件研发工程师
• 搜狐网站诚聘Java、PHP和C++工程师

]]> Sun, 16 Sep 2007 23:54:39 +0800 http://kitsionchen.javaeye.com/blog/124632 http://kitsionchen.javaeye.com/blog/124632 kitsionchen 作者: kitsionchen  链接：http://kitsionchen.javaeye.com/blog/124633  发表时间: 2007年09月16日

声明：本文系JavaEye网站发布的原创博客文章，未经作者书面许可，严禁任何网站转载本文，否则必将追究法律责任！

如何将 Cell Broadband Engine（Cell/B.E.）处理器从一个现成的 Sony PLAYSTATION 3（PS3）上取下来，用它来构造一个基于 Linux 的实验设备呢（也就是，将现有的产品 Cell/B.E. 还原成实验设备）？在本系列文章中，Lewin Edwards 将向您展示如何从游戏控制台转到音频带宽频谱分析器和函数生成器。首先，他将介绍本项目的设计内容，然后在您开始着手在 Cell/B.E. 处理器上生成并分析信号时详细介绍用户接口的实现。
本文的讨论也很精彩，浏览讨论>>


JavaEye推荐

• 北京: 千橡集团暨校内网诚聘软件研发工程师
• 搜狐网站诚聘Java、PHP和C++工程师

]]> Sun, 16 Sep 2007 23:54:39 +0800 http://kitsionchen.javaeye.com/blog/124633 http://kitsionchen.javaeye.com/blog/124633 kitsionchen 作者: kitsionchen  链接：http://kitsionchen.javaeye.com/blog/124634  发表时间: 2007年09月16日

声明：本文系JavaEye网站发布的原创博客文章，未经作者书面许可，严禁任何网站转载本文，否则必将追究法律责任！

新接触 Linux 的用户通常会对有如此众多的发行版可以选择而产生困扰。好消息是我们可以安全地忽略其中的大多数。本文可以帮助您在众多发行版中作出选择，以开始 Linux 的探索，并且能够帮助您理解为什么要选择这种发行版。
本文的讨论也很精彩，浏览讨论>>


JavaEye推荐

• 北京: 千橡集团暨校内网诚聘软件研发工程师
• 搜狐网站诚聘Java、PHP和C++工程师

]]> Sun, 16 Sep 2007 23:54:38 +0800 http://kitsionchen.javaeye.com/blog/124634 http://kitsionchen.javaeye.com/blog/124634