MySQL crashing randomly
the Out-of-memory process (oom) killer terminated your mysql process because it was trying to use more memory than was available. Calculating memory usage in MySQL exactly is very difficult, but once you understand how MySQL allocates memory system-wide and to each connection, you can get a pretty good idea of how much memory is likely to be used. Keep in mind that a big challenge here is figuring out how many connections are open simultaneously and how much each one is doing, since the amount of time a connection hangs around waiting to be reused is settable with server system variables as well.

There are a few tools out there that can help you get a good overview of what the server memory allocation should look like and where potential problems may lie in your current configuration. So long as you're not 100% reliant on any one. mysqltuner.pl will give you a great starting point, and possibly get you close enough to resolve your issue completely. Percona's MySQL Configuration Wizard is very good at generating optimal initial configurations. Run the wizard, generate a configuration, install it, and see how mysqltuner.pl disagrees with it.

You will immediately see that you're miles ahead of where you started in terms of a good configuration, and that it's a complex enough topic that there are many different preferences, priorities, levels of expertise, and areas of focus in deciding what a good configuration looks like, but there's also some numbers that are unquestionably better than others.

As others have mentioned, the reality is that to get good performance you will need a server with more RAM, but setting it up will be easier with the Percona wizard as well as mysqltuner.pl.

Finally, here is a great introduction to what MySQL does with memory. It's from some MySQL documentation I saved years ago, but I could not find the original source just now:

    Mysql Server Memory Usage = Sum of Global Buffers + 
        (number of Connection * Per thread memory variables).
    Global buffers include:
        key_buffer_size: key_buffer_size is the size of the buffer used 
            for index blocks.
        innodb_buffer_pool_size: The size in bytes of the memory buffer 
            InnoDB uses to cache data and indexes of its tables.
        innodb_additional_mem_pool_size: The size in bytes of a memory pool
            InnoDB uses to store data dictionary information and other 
            internal data structures.
        innodb_log_buffer_size: The size in bytes of the buffer that InnoDB 
            uses to write to the log files on disk.
        query_cache_limit: The amount of memory allocated for caching query 
            results.
    Each thread for client connection uses:
        thread_stack – The stack size for each thread.
        net_buffer_length – connection buffer
        max_allowed_packet – up to this size net_buffer_length can grow
        read_buffer_size – used for sequential table scan
        rean_rnd_buffer_size – used for random read buffer / sorting
        tmp_table_size – temporary / hash tables in mysql
        sort_buffer_size – for sorting
    Per thread variables include:
        read_buffer_size: Buffer memory used for sequential table scan.
        read_rnd_buffer_size: Memory used for random read buffer / sorting.
        sort_buffer_size: Memory allocated for sorting, Group By, Order By.
        join_buffer_size: The size of the buffer that is used for plain index 
            scans, range index scans, and joins that do not use indexes and 
            thus perform full table scans.
        thread_stack: The stack size for each thread.
        net_buffer_length: Connection buffer
        max_allowed_packet: Up to this size net_buffer_length can grow.
    Note that,
        If size increases or if table have blob columns, instead of heap 
            tables on-disk tables created.
        Memory for variables read_buffer_size, sort_buffer_size, 
            read_rnd_buffer_size, tmp_table_size are allocated as &amp; when 
            required. They are also de-allocated once the task is 
            accomplished.