Free multiple threads software for linux

Multiple Time Sheets is a simple tool to help you keep track of how many hours you work and for whom.
It differs from most time-tracking software because its designed to work like paper that magically totals up hours.
Main features:
- Uses text files, requiring no database.
- Supports only one user per app, for simpler code.
- Sends and tracks invoices, and payments thereof.
- Features a rudimentary to-do list that displays your list as an outline.
- Sends you a backup of your data automatically.
- Assume the user prefers free-form data entry in text files rather than typing into forms.
- Uses the htmlMimeMail.php class by Richard Heye (phpguru.org).
- CSV and OPML exports of some data.
- Automatic hyperlinking from MTS to your favorite web-based software.
Enhancements:
- This release added a feature that replaces text patterns with links so that strings like "Bug 10" can link to a bug tracking application.
- CSV export was added for the timesheet along with OPML export for the to-do list.

multitask allows Python programs to use generators (aka coroutines) to perform cooperative multitasking and asynchronous I/O. Applications written using multitask consist of a set of cooperating tasks that yield to a shared task manager whenever they perform a (potentially) blocking operation, such as I/O on a socket or getting data from a queue.

The task manager temporarily suspends the task (allowing other tasks to run in the meantime) and then restarts it when the blocking operation is complete. Such an approach is suitable for applications that would otherwise have to use select() and/or multiple threads to achieve concurrency.

This project is free software, distributed under the MIT license.

Examples:

As a very simple example, heres how one could use multitask to allow two unrelated tasks to run concurrently:

>>> def printer(message):
... while True:
... print message
... yield
...
>>> multitask.add(printer(hello))
>>> multitask.add(printer(goodbye))
>>> multitask.run()
hello
goodbye
hello
goodbye
hello
goodbye
[and so on ...]

For a more useful example, heres how one could implement a multitasking server that can handle multiple concurrent client connections:

def listener(sock):
while True:
conn, address = (yield multitask.accept(sock))
multitask.add(client_handler(conn))

def client_handler(sock):
while True:
request = (yield multitask.recv(sock, 1024))
if not request:
break
response = handle_request(request)
yield multitask.send(sock, response)

multitask.add(listener(sock))
multitask.run()

The functions and classes in the multitask module allow tasks to yield for I/O operations on sockets and file descriptors, adding/removing data to/from queues, or sleeping for a specified interval. When yielding, a task can also specify a timeout. If the operation for which the task yielded has not completed after the given number of seconds, the task is restarted, and a Timeout exception is raised at the point of yielding.

Tasks can also yield other tasks, which allows for composition of tasks and reuse of existing multitasking code. A child task runs until it either completes or raises an exception, and its output or exception is propagated to its parent. For example:

>>> def parent():
... try:
... print good child says: %s % (yield child())
... print bad child says: %s % (yield child(bad=True))
... except Exception, e:
... print caught exception: %s % e
...
>>> def child(bad=False):
... if bad:
... raise RuntimeError(oops!)
... yield Hi, Mom!
...
>>> multitask.add(parent())
>>> multitask.run()
good child says: Hi, Mom!
caught exception: oops!

RT-Thread is a real-time operating system. It is designed specifically for small memory footprint platforms. The kernel supports the tranditional RTOS services, such as multiple threads, semaphores, mutexes, event flags, mailboxes, etc.
RT-Thread project also provides a C-expression interpreter shell, from which a programmer can access kernel variables and invoke system functions.
Main features:
Kernel Object System
- There is a kernel object system, which can access and manage all of the kernel objects. Kernel objects include most of the facilities in the kernel, for example, thread, semaphore etc. Kernel objects can be static objects, whose memory is allocated in compiling. It can be dynamic objects as well, whose memory is allocated from system heaps in runtime. Through the kernel object system, RT-Thread operating system can be independent from the memory management system and greatly enhance the scalability of the system.
Multi-Task/Thread Scheduling
- RT-Thread operating system supports multi-task systems, which are based on thread scheduling. The scheduling algorithm used in RT-Thread operating system is a full preemptive priority-based scheduling algorithm. It supports 256 priority levels, in which 0 is the highest and 255 the lowest. The 255th priority is used for idle thread. The scheduling algorithm also supports threads running at same priority level. The shared time-slice round-robin scheduling is used for this case. The time of scheduler to determine the next highest ready thread is determinant. The number of threads in the system is unlimited, only related with RAM.
Synchronization Mechanisms
- RT-Thread operating system supports the traditional semaphore and mutex. Mutex objects use inherited priority to prevent priority reversion. The semaphore release action is safe for interrupt service routine. Moreover, the block queue for thread to obtain semaphore or mutex can be sorted by priority or FIFO.
Inter-Thread Communication
- RT-Thread operating systems supports event/fast event, mail box and message queue. The event mechanism is used to awake a thead by setting one or more corresponding bit of a binary number when an event ocurs. The fast event supports event thread queue. Once a one bit event occurs, the corresponding blocked thread can be found out timing accurately, then will be waked up. In mailbox, a mail length is fixed to 4 byte, which is more effective than message queue. The send action for communication facilities is also safe for interrupt service routine.
Clock and Timer
- In default, the system uses clock tick to implement shared time-slice scheduling. The timing sensitivity of thread is implemented by timers. The timer can be set as one-shot or periodic timeout.
Memory Management
- RT-Thread operating system supports two types memory management: static memory pool management and dynamic memory heap management. The time to allocate a memory block from the memory pool is determinant and when the memory pool is empty, the allocated thread can be blocked (or immediately return, or waiting for sometime to return, which are determined by a timeout parameter). When other thread releases memory blocks to this memory pool, the blocked thread is wake up.
Enhancements:
- More porting was done to Samsung S3C44b0 CPU, AMTEL AT91SAM7S64, Nintendo DS, and Intel i386.

JThread project provides some classes to make use of threads easy on different platforms.
The classes are actually rather simple wrappers around existing thread implementations.
The package contains two classes: JThread and JMutex, which (obviously) represent a thread and a mutex. For unix-like platforms, the class implementations use the pthread library. On an MS-Windows platform, native Win32 threads are used.
The library is totally FREE!
Enhancements:
- The JMutexAutoLock class was added.
- In Win32 and WinCE, it is now possible to use a critical section object instead of a mutex handle.

Threads-pop3d provides a very fast and light THREADS POP3 Daemon which can work with MySQL.

THREADS POP is an implementation of the Post Office Protocol server that conforms fully to the specifications in RFC 1939 (and later ones). For start/stop use /etc/rc.d/init.d/threads-pop3d.init script.

After start THREADS POP uses syslogd to log all messages. If you will have some problems look in the file /var/log/mail.log. This daemon first print there information about started threads. Later you can see information about logged users. If you end work (dont forget about threads-pop3d.init script) you will see how many connections served everyone thread.

The extra one thread show you how many connections daemon needed create for surplus. I.e. your daemon goes with 10 threads. In the one time connect themself 10 clients.

Then server creates next threads to serve next clients. Now every extra client (connected in this same time) increases surpluses counter. After disconnection stays so many children as you gave in -c option. In the one time server cant overdraft MAX_CHILDREN number.

If he does, then next clients must wait for disconnection the connected one.

Monetra (formerly known as MCVE) is a scalable credit card processing engine for Linux and UNIX. The project is designed to handle credit card authorizations and is certified to support major clearing house protocols.
Features include support for multiple modems, multiple merchant accounts, and multiple processors, all simultaneously -- as well as IP and SSL connectivity along side SQL database support.
Designed in C, conforming to POSIX standards, and utilizing light weight processes (threads), this product is able to handle a large number of transactions with high speed and minimal CPU usage.
Enhancements:
- A secure recurring billing module and card storage subsystem returning unique tracking tokens has been added and branded as Monetra DSS.
- This assists integrators with their PCI compliance so they dont need to store card numbers outside of Monetra.
- There is DNS caching for improved latency.
- Givex and FifthThrid 610 support have been added.
- Global Payments, VITAL, and NPC re-certifications.
- Visa gift-card support (balance inquiry and partial auths), as well as new card systems compliance updates for October 2007.
- Mac OS X for Intel, Windows Vista, and OpenBSD 4.0 support has also been added.

Fetchgals is a Web spider that locates and optionally downloads free pictures and movies from the internet.

Today, commercial porn sites are advertised like this: somebody puts together a thumbnail gallery, i.e. a web page with small thumbnail pictures linking to free full-size images or movies, and provides a link to the pay site. These thumbnail galleries are listed on central websites called Thumbnail Gallery Posts (TGPs). Unfortunately, many TGPs add a layer of redirects, popups, spyware and viruses. Fetchgals is designed to eliminate the TGP.

The fetchgals distribution comes with a huge list of TGPs. This list was generated by a separate script called findtgps, which is also included in the distribution. Fetchgals visits these TGPs in order to locate thumbnail galleries. The images and movies of these galleries can then be downloaded. Since theres a couple hundred gigabytes of free porn on the internet at any given time, fetchgals constantly monitors local disk space to avoid overruns. Alternatively, fetchgals can create local HTML pages that link to the known galleries; this minimizes disk and bandwidth usage.

The script is written in perl and uses multiple threads to maximize throughput. Both fetchgals and findtgps are in the public domain.

Inter-Thread Communication (ITC) aims to make it exceedingly easy to call functions in other threads.
The lexer does all the work, so just run the lexer on your headers, then call the stub functions.
In addition, it also provides a complete threading API, with the four threading primitives and a high speed threadsafe FIFO class.
Enhancements:
- It add support for GCC 4.x, and the build system is fixed.